<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE CPP #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE FlexibleInstances #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# LANGUAGE PolyKinds #-}</span><span>
</span><span id="line-4"></span><span class="hs-pragma">{-# LANGUAGE ScopedTypeVariables #-}</span><span>
</span><span id="line-5"></span><span class="hs-pragma">{-# LANGUAGE GADTs #-}</span><span>
</span><span id="line-6"></span><span class="hs-pragma">{-# LANGUAGE MultiWayIf #-}</span><span>
</span><span id="line-7"></span><span class="hs-pragma">{-# LANGUAGE BangPatterns #-}</span><span>
</span><span id="line-8"></span><span class="hs-pragma">{-# LANGUAGE UnboxedTuples #-}</span><span>
</span><span id="line-9"></span><span>
</span><span id="line-10"></span><span class="hs-pragma">{-# OPTIONS_GHC -O2 -funbox-strict-fields #-}</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- We always optimise this, otherwise performance of a non-optimised</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- compiler is severely affected</span><span>
</span><span id="line-13"></span><span>
</span><span id="line-14"></span><span class="hs-comment">--</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- (c) The University of Glasgow 2002-2006</span><span>
</span><span id="line-16"></span><span class="hs-comment">--</span><span>
</span><span id="line-17"></span><span class="hs-comment">-- Binary I/O library, with special tweaks for GHC</span><span>
</span><span id="line-18"></span><span class="hs-comment">--</span><span>
</span><span id="line-19"></span><span class="hs-comment">-- Based on the nhc98 Binary library, which is copyright</span><span>
</span><span id="line-20"></span><span class="hs-comment">-- (c) Malcolm Wallace and Colin Runciman, University of York, 1998.</span><span>
</span><span id="line-21"></span><span class="hs-comment">-- Under the terms of the license for that software, we must tell you</span><span>
</span><span id="line-22"></span><span class="hs-comment">-- where you can obtain the original version of the Binary library, namely</span><span>
</span><span id="line-23"></span><span class="hs-comment">--     http://www.cs.york.ac.uk/fp/nhc98/</span><span>
</span><span id="line-24"></span><span>
</span><span id="line-25"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.Utils.Binary</span><span>
</span><span id="line-26"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="hs-comment">{-type-}</span><span>  </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier">Bin</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-27"></span><span>    </span><span class="hs-comment">{-class-}</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier">Binary</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-28"></span><span>    </span><span class="hs-comment">{-type-}</span><span>  </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier">BinHandle</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-29"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#SymbolTable"><span class="hs-identifier">SymbolTable</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Dictionary"><span class="hs-identifier">Dictionary</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-30"></span><span>
</span><span id="line-31"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier">BinData</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#dataHandle"><span class="hs-identifier">dataHandle</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#handleData"><span class="hs-identifier">handleData</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-32"></span><span>
</span><span id="line-33"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#openBinMem"><span class="hs-identifier">openBinMem</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-34"></span><span class="hs-comment">--   closeBin,</span><span>
</span><span id="line-35"></span><span>
</span><span id="line-36"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier">seekBin</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-37"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier">tellBin</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-38"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#castBin"><span class="hs-identifier">castBin</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-39"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#withBinBuffer"><span class="hs-identifier">withBinBuffer</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-40"></span><span>
</span><span id="line-41"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#writeBinMem"><span class="hs-identifier">writeBinMem</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-42"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#readBinMem"><span class="hs-identifier">readBinMem</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-43"></span><span>
</span><span id="line-44"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#putAt"><span class="hs-identifier">putAt</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getAt"><span class="hs-identifier">getAt</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span>   </span><span class="annot"><span class="hs-comment">-- * For writing instances</span></span><span>
</span><span id="line-47"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier">putByte</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-48"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier">getByte</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-49"></span><span>
</span><span id="line-50"></span><span>   </span><span class="annot"><span class="hs-comment">-- * Variable length encodings</span></span><span>
</span><span id="line-51"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier">putULEB128</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-52"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier">getULEB128</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-53"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier">putSLEB128</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-54"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier">getSLEB128</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-55"></span><span>
</span><span id="line-56"></span><span>   </span><span class="annot"><span class="hs-comment">-- * Fixed length encoding</span></span><span>
</span><span id="line-57"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier">FixedLengthEncoding</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-58"></span><span>
</span><span id="line-59"></span><span>   </span><span class="annot"><span class="hs-comment">-- * Lazy Binary I/O</span></span><span>
</span><span id="line-60"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#lazyGet"><span class="hs-identifier">lazyGet</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-61"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#lazyPut"><span class="hs-identifier">lazyPut</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span>   </span><span class="annot"><span class="hs-comment">-- * User data</span></span><span>
</span><span id="line-64"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier">UserData</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getUserData"><span class="hs-identifier">getUserData</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#setUserData"><span class="hs-identifier">setUserData</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-65"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#newReadState"><span class="hs-identifier">newReadState</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#newWriteState"><span class="hs-identifier">newWriteState</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-66"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#putDictionary"><span class="hs-identifier">putDictionary</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getDictionary"><span class="hs-identifier">getDictionary</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putFS"><span class="hs-identifier">putFS</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-67"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">

#include &quot;HsVersions.h&quot;
</span><span>
</span><span id="line-71"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Prelude.html"><span class="hs-identifier">GHC.Prelude</span></a></span><span>
</span><span id="line-72"></span><span>
</span><span id="line-73"></span><span class="hs-keyword">import</span><span> </span><span class="hs-pragma">{-# SOURCE</span><span> </span><span class="hs-pragma">#-}</span><span> </span><span class="annot"><a href="GHC.Types.Name.html"><span class="hs-identifier">GHC.Types.Name</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier">Name</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-74"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html"><span class="hs-identifier">GHC.Data.FastString</span></a></span><span>
</span><span id="line-75"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Utils.Panic.Plain.html"><span class="hs-identifier">GHC.Utils.Panic.Plain</span></a></span><span>
</span><span id="line-76"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Unique.FM.html"><span class="hs-identifier">GHC.Types.Unique.FM</span></a></span><span>
</span><span id="line-77"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Data.FastMutInt.html"><span class="hs-identifier">GHC.Data.FastMutInt</span></a></span><span>
</span><span id="line-78"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Utils.Fingerprint.html"><span class="hs-identifier">GHC.Utils.Fingerprint</span></a></span><span>
</span><span id="line-79"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.Basic.html"><span class="hs-identifier">GHC.Types.Basic</span></a></span><span>
</span><span id="line-80"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html"><span class="hs-identifier">GHC.Types.SrcLoc</span></a></span><span>
</span><span id="line-81"></span><span>
</span><span id="line-82"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../deepseq/src/Control.DeepSeq.html#"><span class="hs-identifier">Control.DeepSeq</span></a></span><span>
</span><span id="line-83"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.html#"><span class="hs-identifier">Foreign</span></a></span><span>
</span><span id="line-84"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../array/src/Data.Array.html#"><span class="hs-identifier">Data.Array</span></a></span><span>
</span><span id="line-85"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.html#"><span class="hs-identifier">Data.ByteString</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier">ByteString</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-86"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#"><span class="hs-identifier">Data.ByteString.Internal</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">BS</span></span><span>
</span><span id="line-87"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Unsafe.html#"><span class="hs-identifier">Data.ByteString.Unsafe</span></a></span><span>   </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">BS</span></span><span>
</span><span id="line-88"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.IORef.html#"><span class="hs-identifier">Data.IORef</span></a></span><span>
</span><span id="line-89"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Char.html#"><span class="hs-identifier">Data.Char</span></a></span><span>                </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#ord"><span class="hs-identifier">ord</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Char.html#chr"><span class="hs-identifier">chr</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-90"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../time/src/Data.Time.html#"><span class="hs-identifier">Data.Time</span></a></span><span>
</span><span id="line-91"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.List.html#"><span class="hs-identifier">Data.List</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.OldList.html#unfoldr"><span class="hs-identifier">unfoldr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-92"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Type.Reflection.html#"><span class="hs-identifier">Type.Reflection</span></a></span><span>
</span><span id="line-93"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Type.Reflection.Unsafe.html#"><span class="hs-identifier">Type.Reflection.Unsafe</span></a></span><span>
</span><span id="line-94"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Kind.html#"><span class="hs-identifier">Data.Kind</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-95"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Exts.html#"><span class="hs-identifier">GHC.Exts</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier">TYPE</span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier">RuntimeRep</span></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier">VecCount</span></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="hs-identifier">VecElem</span></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-96"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span>            </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier">when</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#%3C%24%21%3E"><span class="hs-operator">(&lt;$!&gt;)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier">unless</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-97"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/System.IO.html#"><span class="hs-identifier">System.IO</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">IO</span></span><span>
</span><span id="line-98"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/System.IO.Unsafe.html#"><span class="hs-identifier">System.IO.Unsafe</span></a></span><span>         </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.Unsafe.html#unsafeInterleaveIO"><span class="hs-identifier">unsafeInterleaveIO</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-99"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/System.IO.Error.html#"><span class="hs-identifier">System.IO.Error</span></a></span><span>          </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/System.IO.Error.html#mkIOError"><span class="hs-identifier">mkIOError</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/System.IO.Error.html#eofErrorType"><span class="hs-identifier">eofErrorType</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-100"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#"><span class="hs-identifier">GHC.Real</span></a></span><span>                 </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Ratio"><span class="hs-identifier">Ratio</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-101"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Serialized.html#"><span class="hs-identifier">GHC.Serialized</span></a></span><span class="hs-cpp">
#if MIN_VERSION_base(4,15,0)
</span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.ForeignPtr.html#"><span class="hs-identifier">GHC.ForeignPtr</span></a></span><span>           </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier">unsafeWithForeignPtr</span></a></span><span> </span><span class="hs-special">)</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-106"></span><span class="hs-keyword">type</span><span> </span><span id="BinArray"><span class="annot"><a href="GHC.Utils.Binary.html#BinArray"><span class="hs-identifier hs-var">BinArray</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.ForeignPtr.html#ForeignPtr"><span class="hs-identifier hs-type">ForeignPtr</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-cpp">

#if !MIN_VERSION_base(4,15,0)
</span><span class="hs-identifier">unsafeWithForeignPtr</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-identifier">ForeignPtr</span><span> </span><span class="hs-identifier">a</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">Ptr</span><span> </span><span class="hs-identifier">a</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-identifier">IO</span><span> </span><span class="hs-identifier">b</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-identifier">IO</span><span> </span><span class="hs-identifier">b</span><span>
</span><span id="line-110"></span><span class="hs-identifier">unsafeWithForeignPtr</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-identifier">withForeignPtr</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-113"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-114"></span><span class="hs-comment">-- BinData</span><span>
</span><span id="line-115"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span class="hs-keyword">data</span><span> </span><span id="BinData"><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-var">BinData</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="BinData"><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-var">BinData</span></a></span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinArray"><span class="hs-identifier hs-type">BinArray</span></a></span><span>
</span><span id="line-118"></span><span>
</span><span id="line-119"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="../../deepseq/src/Control.DeepSeq.html#NFData"><span class="hs-identifier hs-type">NFData</span></a></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-120"></span><span>  </span><span id="local-6989586621680793946"><span class="annot"><span class="annottext">rnf :: BinData -&gt; ()
</span><a href="../../deepseq/src/Control.DeepSeq.html#rnf"><span class="hs-identifier hs-var hs-var hs-var hs-var">rnf</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span> </span><span id="local-6989586621680793944"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793944"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ()
forall a. NFData a =&gt; a -&gt; ()
</span><a href="../../deepseq/src/Control.DeepSeq.html#rnf"><span class="hs-identifier hs-var">rnf</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793944"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-121"></span><span>
</span><span id="line-122"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793941"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-123"></span><span>  </span><span id="local-6989586621680793936"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; BinData -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793934"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793934"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span> </span><span id="local-6989586621680793933"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793933"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span id="local-6989586621680793932"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793932"><span class="hs-identifier hs-var">dat</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-124"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793934"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793933"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-125"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793934"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793933"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793930"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793930"><span class="hs-identifier hs-var">dest</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-126"></span><span>      </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793932"><span class="hs-identifier hs-var">dat</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793929"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793929"><span class="hs-identifier hs-var">orig</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-127"></span><span>        </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
forall a. Ptr a -&gt; Ptr a -&gt; Int -&gt; IO ()
</span><a href="../../base/src/Foreign.Marshal.Utils.html#copyBytes"><span class="hs-identifier hs-var">copyBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793930"><span class="hs-identifier hs-var">dest</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793929"><span class="hs-identifier hs-var">orig</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793933"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-128"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-129"></span><span>  </span><span id="local-6989586621680793922"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO BinData
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793920"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793920"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-130"></span><span>    </span><span id="local-6989586621680793919"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793919"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793920"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-131"></span><span>    </span><span id="local-6989586621680793918"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793918"><span class="hs-identifier hs-var">dat</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IO BinArray
forall a. Int -&gt; IO (ForeignPtr a)
</span><a href="../../base/src/GHC.ForeignPtr.html#mallocForeignPtrBytes"><span class="hs-identifier hs-var">mallocForeignPtrBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793919"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-132"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793920"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793919"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793915"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793915"><span class="hs-identifier hs-var">orig</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-133"></span><span>      </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793918"><span class="hs-identifier hs-var">dat</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793914"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793914"><span class="hs-identifier hs-var">dest</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-134"></span><span>        </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
forall a. Ptr a -&gt; Ptr a -&gt; Int -&gt; IO ()
</span><a href="../../base/src/Foreign.Marshal.Utils.html#copyBytes"><span class="hs-identifier hs-var">copyBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793914"><span class="hs-identifier hs-var">dest</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793915"><span class="hs-identifier hs-var">orig</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793919"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-135"></span><span>    </span><span class="annot"><span class="annottext">BinData -&gt; IO BinData
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; BinArray -&gt; BinData
</span><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-var">BinData</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793919"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793918"><span class="hs-identifier hs-var">dat</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-136"></span><span>
</span><span id="line-137"></span><span class="annot"><a href="GHC.Utils.Binary.html#dataHandle"><span class="hs-identifier hs-type">dataHandle</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span>
</span><span id="line-138"></span><span id="dataHandle"><span class="annot"><span class="annottext">dataHandle :: BinData -&gt; IO BinHandle
</span><a href="GHC.Utils.Binary.html#dataHandle"><span class="hs-identifier hs-var hs-var">dataHandle</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span> </span><span id="local-6989586621680793913"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793913"><span class="hs-identifier hs-var">size</span></a></span></span><span> </span><span id="local-6989586621680793912"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793912"><span class="hs-identifier hs-var">bin</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-139"></span><span>  </span><span id="local-6989586621680793911"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793911"><span class="hs-identifier hs-var">ixr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-140"></span><span>  </span><span id="local-6989586621680793909"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793909"><span class="hs-identifier hs-var">szr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-141"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793911"><span class="hs-identifier hs-var">ixr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-142"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793909"><span class="hs-identifier hs-var">szr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793913"><span class="hs-identifier hs-var">size</span></a></span><span>
</span><span id="line-143"></span><span>  </span><span id="local-6989586621680793907"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793907"><span class="hs-identifier hs-var">binr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinArray -&gt; IO (IORef BinArray)
forall a. a -&gt; IO (IORef a)
</span><a href="../../base/src/GHC.IORef.html#newIORef"><span class="hs-identifier hs-var">newIORef</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793912"><span class="hs-identifier hs-var">bin</span></a></span><span>
</span><span id="line-144"></span><span>  </span><span class="annot"><span class="annottext">BinHandle -&gt; IO BinHandle
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UserData -&gt; FastMutInt -&gt; FastMutInt -&gt; IORef BinArray -&gt; BinHandle
</span><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-var">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
forall a. a
</span><a href="GHC.Utils.Binary.html#noUserData"><span class="hs-identifier hs-var">noUserData</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793911"><span class="hs-identifier hs-var">ixr</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793909"><span class="hs-identifier hs-var">szr</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793907"><span class="hs-identifier hs-var">binr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-145"></span><span>
</span><span id="line-146"></span><span class="annot"><a href="GHC.Utils.Binary.html#handleData"><span class="hs-identifier hs-type">handleData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-type">BinData</span></a></span><span>
</span><span id="line-147"></span><span id="handleData"><span class="annot"><span class="annottext">handleData :: BinHandle -&gt; IO BinData
</span><a href="GHC.Utils.Binary.html#handleData"><span class="hs-identifier hs-var hs-var">handleData</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793903"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793903"><span class="hs-identifier hs-var">ixr</span></a></span></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793902"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793902"><span class="hs-identifier hs-var">binr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; BinArray -&gt; BinData
</span><a href="GHC.Utils.Binary.html#BinData"><span class="hs-identifier hs-var">BinData</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; BinArray -&gt; BinData) -&gt; IO Int -&gt; IO (BinArray -&gt; BinData)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793903"><span class="hs-identifier hs-var">ixr</span></a></span><span> </span><span class="annot"><span class="annottext">IO (BinArray -&gt; BinData) -&gt; IO BinArray -&gt; IO BinData
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793902"><span class="hs-identifier hs-var">binr</span></a></span><span>
</span><span id="line-148"></span><span>
</span><span id="line-149"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-150"></span><span class="hs-comment">-- BinHandle</span><span>
</span><span id="line-151"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-152"></span><span>
</span><span id="line-153"></span><span class="hs-keyword">data</span><span> </span><span id="BinHandle"><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-var">BinHandle</span></a></span></span><span>
</span><span id="line-154"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span id="BinMem"><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-var">BinMem</span></a></span></span><span> </span><span class="hs-special">{</span><span>                     </span><span class="hs-comment">-- binary data stored in an unboxed array</span><span>
</span><span id="line-155"></span><span>     </span><span id="bh_usr"><span class="annot"><span class="annottext">BinHandle -&gt; UserData
</span><a href="GHC.Utils.Binary.html#bh_usr"><span class="hs-identifier hs-var hs-var">bh_usr</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span class="hs-special">,</span><span>         </span><span class="hs-comment">-- sigh, need parameterized modules :-)</span><span>
</span><span id="line-156"></span><span>     </span><span id="_off_r"><span class="annot"><span class="annottext">BinHandle -&gt; FastMutInt
</span><a href="GHC.Utils.Binary.html#_off_r"><span class="hs-identifier hs-var hs-var">_off_r</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.Data.FastMutInt.html#FastMutInt"><span class="hs-identifier hs-type">FastMutInt</span></a></span><span class="hs-special">,</span><span>      </span><span class="hs-comment">-- the current offset</span><span>
</span><span id="line-157"></span><span>     </span><span id="_sz_r"><span class="annot"><span class="annottext">BinHandle -&gt; FastMutInt
</span><a href="GHC.Utils.Binary.html#_sz_r"><span class="hs-identifier hs-var hs-var">_sz_r</span></a></span></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="annot"><a href="GHC.Data.FastMutInt.html#FastMutInt"><span class="hs-identifier hs-type">FastMutInt</span></a></span><span class="hs-special">,</span><span>      </span><span class="hs-comment">-- size of the array (cached)</span><span>
</span><span id="line-158"></span><span>     </span><span id="_arr_r"><span class="annot"><span class="annottext">BinHandle -&gt; IORef BinArray
</span><a href="GHC.Utils.Binary.html#_arr_r"><span class="hs-identifier hs-var hs-var">_arr_r</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-glyph">!</span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.IORef.html#IORef"><span class="hs-identifier hs-type">IORef</span></a></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinArray"><span class="hs-identifier hs-type">BinArray</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-comment">-- the array (bounds: (0,size-1))</span><span>
</span><span id="line-159"></span><span>    </span><span class="hs-special">}</span><span>
</span><span id="line-160"></span><span>        </span><span class="hs-comment">-- XXX: should really store a &quot;high water mark&quot; for dumping out</span><span>
</span><span id="line-161"></span><span>        </span><span class="hs-comment">-- the binary data to a file.</span><span>
</span><span id="line-162"></span><span>
</span><span id="line-163"></span><span class="annot"><a href="GHC.Utils.Binary.html#getUserData"><span class="hs-identifier hs-type">getUserData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span>
</span><span id="line-164"></span><span id="getUserData"><span class="annot"><span class="annottext">getUserData :: BinHandle -&gt; UserData
</span><a href="GHC.Utils.Binary.html#getUserData"><span class="hs-identifier hs-var hs-var">getUserData</span></a></span></span><span> </span><span id="local-6989586621680793894"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793894"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; UserData
</span><a href="GHC.Utils.Binary.html#bh_usr"><span class="hs-identifier hs-var hs-var">bh_usr</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793894"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-165"></span><span>
</span><span id="line-166"></span><span class="annot"><a href="GHC.Utils.Binary.html#setUserData"><span class="hs-identifier hs-type">setUserData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span>
</span><span id="line-167"></span><span id="setUserData"><span class="annot"><span class="annottext">setUserData :: BinHandle -&gt; UserData -&gt; BinHandle
</span><a href="GHC.Utils.Binary.html#setUserData"><span class="hs-identifier hs-var hs-var">setUserData</span></a></span></span><span> </span><span id="local-6989586621680793893"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793893"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793892"><span class="annot"><span class="annottext">UserData
</span><a href="#local-6989586621680793892"><span class="hs-identifier hs-var">us</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793893"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">bh_usr :: UserData
</span><a href="GHC.Utils.Binary.html#bh_usr"><span class="hs-identifier hs-var">bh_usr</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UserData
</span><a href="#local-6989586621680793892"><span class="hs-identifier hs-var">us</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-168"></span><span>
</span><span id="line-169"></span><span class="hs-comment">-- | Get access to the underlying buffer.</span><span>
</span><span id="line-170"></span><span class="hs-comment">--</span><span>
</span><span id="line-171"></span><span class="hs-comment">-- It is quite important that no references to the 'ByteString' leak out of the</span><span>
</span><span id="line-172"></span><span class="hs-comment">-- continuation lest terrible things happen.</span><span>
</span><span id="line-173"></span><span id="local-6989586621680794822"><span class="annot"><a href="GHC.Utils.Binary.html#withBinBuffer"><span class="hs-identifier hs-type">withBinBuffer</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794822"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794822"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-174"></span><span id="withBinBuffer"><span class="annot"><span class="annottext">withBinBuffer :: forall a. BinHandle -&gt; (ByteString -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#withBinBuffer"><span class="hs-identifier hs-var hs-var">withBinBuffer</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793888"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793888"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793887"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793887"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680793886"><span class="annot"><span class="annottext">ByteString -&gt; IO a
</span><a href="#local-6989586621680793886"><span class="hs-identifier hs-var">action</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-175"></span><span>  </span><span id="local-6989586621680793885"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793885"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793887"><span class="hs-identifier hs-var">arr_r</span></a></span><span>
</span><span id="line-176"></span><span>  </span><span id="local-6989586621680793884"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793884"><span class="hs-identifier hs-var">ix</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793888"><span class="hs-identifier hs-var">ix_r</span></a></span><span>
</span><span id="line-177"></span><span>  </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#withForeignPtr"><span class="hs-identifier hs-var">withForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793885"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO a) -&gt; IO a) -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793882"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793882"><span class="hs-identifier hs-var">ptr</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-178"></span><span>    </span><span class="annot"><span class="annottext">CStringLen -&gt; IO ByteString
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafePackCStringLen"><span class="hs-identifier hs-var">BS.unsafePackCStringLen</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr CChar
forall a b. Ptr a -&gt; Ptr b
</span><a href="../../base/src/GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793882"><span class="hs-identifier hs-var">ptr</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793884"><span class="hs-identifier hs-var">ix</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO ByteString -&gt; (ByteString -&gt; IO a) -&gt; IO a
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString -&gt; IO a
</span><a href="#local-6989586621680793886"><span class="hs-identifier hs-var">action</span></a></span><span>
</span><span id="line-179"></span><span>
</span><span id="line-180"></span><span>
</span><span id="line-181"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-182"></span><span class="hs-comment">-- Bin</span><span>
</span><span id="line-183"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-184"></span><span>
</span><span id="line-185"></span><span class="hs-keyword">newtype</span><span> </span><span id="Bin"><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-var">Bin</span></a></span></span><span> </span><span id="local-6989586621680794810"><span class="annot"><a href="#local-6989586621680794810"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="BinPtr"><span class="annot"><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-var">BinPtr</span></a></span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-186"></span><span>  </span><span class="hs-keyword">deriving</span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793873"><span id="local-6989586621680793877"><span class="annot"><span class="annottext">Bin a -&gt; Bin a -&gt; Bool
(Bin a -&gt; Bin a -&gt; Bool) -&gt; (Bin a -&gt; Bin a -&gt; Bool) -&gt; Eq (Bin a)
forall a. (a -&gt; a -&gt; Bool) -&gt; (a -&gt; a -&gt; Bool) -&gt; Eq a
forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
/= :: Bin a -&gt; Bin a -&gt; Bool
$c/= :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
== :: Bin a -&gt; Bin a -&gt; Bool
$c== :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
</span><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var">Eq</span></span></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793841"><span id="local-6989586621680793845"><span id="local-6989586621680793849"><span id="local-6989586621680793853"><span id="local-6989586621680793857"><span id="local-6989586621680793861"><span id="local-6989586621680793865"><span class="annot"><span class="annottext">Eq (Bin a)
Eq (Bin a)
-&gt; (Bin a -&gt; Bin a -&gt; Ordering)
-&gt; (Bin a -&gt; Bin a -&gt; Bool)
-&gt; (Bin a -&gt; Bin a -&gt; Bool)
-&gt; (Bin a -&gt; Bin a -&gt; Bool)
-&gt; (Bin a -&gt; Bin a -&gt; Bool)
-&gt; (Bin a -&gt; Bin a -&gt; Bin a)
-&gt; (Bin a -&gt; Bin a -&gt; Bin a)
-&gt; Ord (Bin a)
Bin a -&gt; Bin a -&gt; Bool
Bin a -&gt; Bin a -&gt; Ordering
Bin a -&gt; Bin a -&gt; Bin a
forall a.
Eq a
-&gt; (a -&gt; a -&gt; Ordering)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; Bool)
-&gt; (a -&gt; a -&gt; a)
-&gt; (a -&gt; a -&gt; a)
-&gt; Ord a
forall k (a :: k). Eq (Bin a)
forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
forall k (a :: k). Bin a -&gt; Bin a -&gt; Ordering
forall k (a :: k). Bin a -&gt; Bin a -&gt; Bin a
min :: Bin a -&gt; Bin a -&gt; Bin a
$cmin :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bin a
max :: Bin a -&gt; Bin a -&gt; Bin a
$cmax :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bin a
&gt;= :: Bin a -&gt; Bin a -&gt; Bool
$c&gt;= :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
&gt; :: Bin a -&gt; Bin a -&gt; Bool
$c&gt; :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
&lt;= :: Bin a -&gt; Bin a -&gt; Bool
$c&lt;= :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
&lt; :: Bin a -&gt; Bin a -&gt; Bool
$c&lt; :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Bool
compare :: Bin a -&gt; Bin a -&gt; Ordering
$ccompare :: forall k (a :: k). Bin a -&gt; Bin a -&gt; Ordering
</span><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var">Ord</span></span></span></span></span></span></span></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793829"><span id="local-6989586621680793831"><span id="local-6989586621680793835"><span class="annot"><span class="annottext">Int -&gt; Bin a -&gt; ShowS
[Bin a] -&gt; ShowS
Bin a -&gt; String
(Int -&gt; Bin a -&gt; ShowS)
-&gt; (Bin a -&gt; String) -&gt; ([Bin a] -&gt; ShowS) -&gt; Show (Bin a)
forall a.
(Int -&gt; a -&gt; ShowS) -&gt; (a -&gt; String) -&gt; ([a] -&gt; ShowS) -&gt; Show a
forall k (a :: k). Int -&gt; Bin a -&gt; ShowS
forall k (a :: k). [Bin a] -&gt; ShowS
forall k (a :: k). Bin a -&gt; String
showList :: [Bin a] -&gt; ShowS
$cshowList :: forall k (a :: k). [Bin a] -&gt; ShowS
show :: Bin a -&gt; String
$cshow :: forall k (a :: k). Bin a -&gt; String
showsPrec :: Int -&gt; Bin a -&gt; ShowS
$cshowsPrec :: forall k (a :: k). Int -&gt; Bin a -&gt; ShowS
</span><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var hs-var hs-var">Show</span></a></span></span></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793821"><span id="local-6989586621680793826"><span class="annot"><span class="annottext">Bin a
Bin a -&gt; Bin a -&gt; Bounded (Bin a)
forall a. a -&gt; a -&gt; Bounded a
forall k (a :: k). Bin a
maxBound :: Bin a
$cmaxBound :: forall k (a :: k). Bin a
minBound :: Bin a
$cminBound :: forall k (a :: k). Bin a
</span><a href="../../base/src/GHC.Enum.html#Bounded"><span class="hs-identifier hs-var hs-var hs-var hs-var hs-var hs-var">Bounded</span></a></span></span></span><span class="hs-special">)</span><span>
</span><span id="line-187"></span><span>
</span><span id="line-188"></span><span id="local-6989586621680794798"><span id="local-6989586621680794799"><span class="annot"><a href="GHC.Utils.Binary.html#castBin"><span class="hs-identifier hs-type">castBin</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794799"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794798"><span class="hs-identifier hs-type">b</span></a></span></span></span><span>
</span><span id="line-189"></span><span id="castBin"><span class="annot"><span class="annottext">castBin :: forall {k} {k} (a :: k) (b :: k). Bin a -&gt; Bin b
</span><a href="GHC.Utils.Binary.html#castBin"><span class="hs-identifier hs-var hs-var">castBin</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-type">BinPtr</span></a></span><span> </span><span id="local-6989586621680793816"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793816"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Bin b
forall {k} (a :: k). Int -&gt; Bin a
</span><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-var">BinPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793816"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-190"></span><span>
</span><span id="line-191"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-192"></span><span class="hs-comment">-- class Binary</span><span>
</span><span id="line-193"></span><span class="hs-comment">---------------------------------------------------------------</span><span>
</span><span id="line-194"></span><span>
</span><span id="line-195"></span><span class="hs-comment">-- | Do not rely on instance sizes for general types,</span><span>
</span><span id="line-196"></span><span class="hs-comment">-- we use variable length encoding for many of them.</span><span>
</span><span id="line-197"></span><span class="hs-keyword">class</span><span> </span><span id="Binary"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-var">Binary</span></a></span></span><span> </span><span id="local-6989586621680794846"><span class="annot"><a href="#local-6989586621680794846"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-198"></span><span>    </span><span id="put_"><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-type">put_</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794846"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-199"></span><span>    </span><span id="put"><span class="annot"><a href="GHC.Utils.Binary.html#put"><span class="hs-identifier hs-type">put</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794846"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794846"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-200"></span><span>    </span><span id="get"><span class="annot"><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-type">get</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794846"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-201"></span><span>
</span><span id="line-202"></span><span>    </span><span class="hs-comment">-- define one of put_, put.  Use of put_ is recommended because it</span><span>
</span><span id="line-203"></span><span>    </span><span class="hs-comment">-- is more likely that tail-calls can kick in, and we rarely need the</span><span>
</span><span id="line-204"></span><span>    </span><span class="hs-comment">-- position return value.</span><span>
</span><span id="line-205"></span><span>    </span><span id="local-6989586621680793813"><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var hs-var">put_</span></a></span><span> </span><span id="local-6989586621680793809"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793809"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793808"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793808"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Bin a
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO (Bin a)
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#put"><span class="hs-identifier hs-var">put</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793809"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793808"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-206"></span><span>    </span><span id="local-6989586621680793807"><span class="annot"><a href="GHC.Utils.Binary.html#put"><span class="hs-identifier hs-var hs-var">put</span></a></span><span> </span><span id="local-6989586621680793802"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793802"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793801"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793801"><span class="hs-identifier hs-var">a</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793800"><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793800"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Bin a)
forall {k} (a :: k). BinHandle -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-var">tellBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793802"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793802"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793801"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Bin a -&gt; IO (Bin a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793800"><span class="hs-identifier hs-var">p</span></a></span></span><span>
</span><span id="line-207"></span><span>
</span><span id="line-208"></span><span id="local-6989586621680794791"><span class="annot"><a href="GHC.Utils.Binary.html#putAt"><span class="hs-identifier hs-type">putAt</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794791"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794791"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794791"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-209"></span><span id="putAt"><span class="annot"><span class="annottext">putAt :: forall a. Binary a =&gt; BinHandle -&gt; Bin a -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putAt"><span class="hs-identifier hs-var hs-var">putAt</span></a></span></span><span> </span><span id="local-6989586621680793794"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793794"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793793"><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793793"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621680793792"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793792"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin a -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-var">seekBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793794"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793793"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793794"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793792"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-210"></span><span>
</span><span id="line-211"></span><span id="local-6989586621680794787"><span class="annot"><a href="GHC.Utils.Binary.html#getAt"><span class="hs-identifier hs-type">getAt</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794787"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794787"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794787"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-212"></span><span id="getAt"><span class="annot"><span class="annottext">getAt :: forall a. Binary a =&gt; BinHandle -&gt; Bin a -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getAt"><span class="hs-identifier hs-var hs-var">getAt</span></a></span></span><span> </span><span id="local-6989586621680793788"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793788"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793787"><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793787"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin a -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-var">seekBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793788"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680793787"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793788"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-213"></span><span>
</span><span id="line-214"></span><span class="annot"><a href="GHC.Utils.Binary.html#openBinMem"><span class="hs-identifier hs-type">openBinMem</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span>
</span><span id="line-215"></span><span id="openBinMem"><span class="annot"><span class="annottext">openBinMem :: Int -&gt; IO BinHandle
</span><a href="GHC.Utils.Binary.html#openBinMem"><span class="hs-identifier hs-var hs-var">openBinMem</span></a></span></span><span> </span><span id="local-6989586621680793786"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793786"><span class="hs-identifier hs-var">size</span></a></span></span><span>
</span><span id="line-216"></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793786"><span class="hs-identifier hs-var">size</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO BinHandle
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Data.Binary.openBinMem: size must be &gt;= 0&quot;</span></span><span>
</span><span id="line-217"></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-218"></span><span>   </span><span id="local-6989586621680793783"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793783"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IO BinArray
forall a. Int -&gt; IO (ForeignPtr a)
</span><a href="../../base/src/GHC.ForeignPtr.html#mallocForeignPtrBytes"><span class="hs-identifier hs-var">mallocForeignPtrBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793786"><span class="hs-identifier hs-var">size</span></a></span><span>
</span><span id="line-219"></span><span>   </span><span id="local-6989586621680793782"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793782"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinArray -&gt; IO (IORef BinArray)
forall a. a -&gt; IO (IORef a)
</span><a href="../../base/src/GHC.IORef.html#newIORef"><span class="hs-identifier hs-var">newIORef</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793783"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-220"></span><span>   </span><span id="local-6989586621680793781"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793781"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-221"></span><span>   </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793781"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-222"></span><span>   </span><span id="local-6989586621680793780"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793780"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-223"></span><span>   </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793780"><span class="hs-identifier hs-var">sz_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793786"><span class="hs-identifier hs-var">size</span></a></span><span>
</span><span id="line-224"></span><span>   </span><span class="annot"><span class="annottext">BinHandle -&gt; IO BinHandle
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UserData -&gt; FastMutInt -&gt; FastMutInt -&gt; IORef BinArray -&gt; BinHandle
</span><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-var">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
forall a. a
</span><a href="GHC.Utils.Binary.html#noUserData"><span class="hs-identifier hs-var">noUserData</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793781"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793780"><span class="hs-identifier hs-var">sz_r</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793782"><span class="hs-identifier hs-var">arr_r</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-225"></span><span>
</span><span id="line-226"></span><span id="local-6989586621680794792"><span class="annot"><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-type">tellBin</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794792"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-227"></span><span id="tellBin"><span class="annot"><span class="annottext">tellBin :: forall {k} (a :: k). BinHandle -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-var hs-var">tellBin</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793777"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793777"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793776"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793776"><span class="hs-identifier hs-var">ix</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793777"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Bin a -&gt; IO (Bin a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Bin a
forall {k} (a :: k). Int -&gt; Bin a
</span><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-var">BinPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793776"><span class="hs-identifier hs-var">ix</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-228"></span><span>
</span><span id="line-229"></span><span id="local-6989586621680794788"><span class="annot"><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-type">seekBin</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794788"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-230"></span><span id="seekBin"><span class="annot"><span class="annottext">seekBin :: forall {k} (a :: k). BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-var hs-var">seekBin</span></a></span></span><span> </span><span id="local-6989586621680793772"><span class="annot"><span class="annottext">h :: BinHandle
</span><a href="#local-6989586621680793772"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793771"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793771"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span id="local-6989586621680793770"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793770"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-type">BinPtr</span></a></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793769"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793769"><span class="hs-identifier hs-var">p</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-231"></span><span>  </span><span id="local-6989586621680793768"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793768"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793770"><span class="hs-identifier hs-var">sz_r</span></a></span><span>
</span><span id="line-232"></span><span>  </span><span class="hs-keyword">if</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793769"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793768"><span class="hs-identifier hs-var">sz</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-233"></span><span>        </span><span class="hs-keyword">then</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#expandBin"><span class="hs-identifier hs-var">expandBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793772"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793769"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793771"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793769"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-234"></span><span>        </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793771"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793769"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-235"></span><span>
</span><span id="line-236"></span><span class="annot"><a href="GHC.Utils.Binary.html#writeBinMem"><span class="hs-identifier hs-type">writeBinMem</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#FilePath"><span class="hs-identifier hs-type">FilePath</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-237"></span><span id="writeBinMem"><span class="annot"><span class="annottext">writeBinMem :: BinHandle -&gt; String -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#writeBinMem"><span class="hs-identifier hs-var hs-var">writeBinMem</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793765"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793765"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793764"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793764"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680793763"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680793763"><span class="hs-identifier hs-var">fn</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-238"></span><span>  </span><span id="local-6989586621680793762"><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793762"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; IOMode -&gt; IO Handle
</span><a href="../../base/src/GHC.IO.StdHandles.html#openBinaryFile"><span class="hs-identifier hs-var">openBinaryFile</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680793763"><span class="hs-identifier hs-var">fn</span></a></span><span> </span><span class="annot"><span class="annottext">IOMode
</span><a href="../../base/src/GHC.IO.IOMode.html#WriteMode"><span class="hs-identifier hs-var">WriteMode</span></a></span><span>
</span><span id="line-239"></span><span>  </span><span id="local-6989586621680793759"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793759"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793764"><span class="hs-identifier hs-var">arr_r</span></a></span><span>
</span><span id="line-240"></span><span>  </span><span id="local-6989586621680793758"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793758"><span class="hs-identifier hs-var">ix</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793765"><span class="hs-identifier hs-var">ix_r</span></a></span><span>
</span><span id="line-241"></span><span>  </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793759"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793757"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793757"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Handle -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
forall a. Handle -&gt; Ptr a -&gt; Int -&gt; IO ()
</span><a href="../../base/src/GHC.IO.Handle.Text.html#hPutBuf"><span class="hs-identifier hs-var">hPutBuf</span></a></span><span> </span><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793762"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793757"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793758"><span class="hs-identifier hs-var">ix</span></a></span><span>
</span><span id="line-242"></span><span>  </span><span class="annot"><span class="annottext">Handle -&gt; IO ()
</span><a href="../../base/src/GHC.IO.Handle.html#hClose"><span class="hs-identifier hs-var">hClose</span></a></span><span> </span><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793762"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-243"></span><span>
</span><span id="line-244"></span><span class="annot"><a href="GHC.Utils.Binary.html#readBinMem"><span class="hs-identifier hs-type">readBinMem</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#FilePath"><span class="hs-identifier hs-type">FilePath</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span>
</span><span id="line-245"></span><span class="hs-comment">-- Return a BinHandle with a totally undefined State</span><span>
</span><span id="line-246"></span><span id="readBinMem"><span class="annot"><span class="annottext">readBinMem :: String -&gt; IO BinHandle
</span><a href="GHC.Utils.Binary.html#readBinMem"><span class="hs-identifier hs-var hs-var">readBinMem</span></a></span></span><span> </span><span id="local-6989586621680793754"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680793754"><span class="hs-identifier hs-var">filename</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-247"></span><span>  </span><span id="local-6989586621680793753"><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793753"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">String -&gt; IOMode -&gt; IO Handle
</span><a href="../../base/src/GHC.IO.StdHandles.html#openBinaryFile"><span class="hs-identifier hs-var">openBinaryFile</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680793754"><span class="hs-identifier hs-var">filename</span></a></span><span> </span><span class="annot"><span class="annottext">IOMode
</span><a href="../../base/src/GHC.IO.IOMode.html#ReadMode"><span class="hs-identifier hs-var">ReadMode</span></a></span><span>
</span><span id="line-248"></span><span>  </span><span id="local-6989586621680793751"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680793751"><span class="hs-identifier hs-var">filesize'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Handle -&gt; IO Integer
</span><a href="../../base/src/GHC.IO.Handle.html#hFileSize"><span class="hs-identifier hs-var">hFileSize</span></a></span><span> </span><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793753"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-249"></span><span>  </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680793749"><span class="annot"><span class="annottext">filesize :: Int
</span><a href="#local-6989586621680793749"><span class="hs-identifier hs-var hs-var">filesize</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680793751"><span class="hs-identifier hs-var">filesize'</span></a></span><span>
</span><span id="line-250"></span><span>  </span><span id="local-6989586621680793748"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793748"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IO BinArray
forall a. Int -&gt; IO (ForeignPtr a)
</span><a href="../../base/src/GHC.ForeignPtr.html#mallocForeignPtrBytes"><span class="hs-identifier hs-var">mallocForeignPtrBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793749"><span class="hs-identifier hs-var">filesize</span></a></span><span>
</span><span id="line-251"></span><span>  </span><span id="local-6989586621680793747"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793747"><span class="hs-identifier hs-var">count</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO Int) -&gt; IO Int
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793748"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO Int) -&gt; IO Int)
-&gt; (Ptr Word8 -&gt; IO Int) -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793746"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793746"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Handle -&gt; Ptr Word8 -&gt; Int -&gt; IO Int
forall a. Handle -&gt; Ptr a -&gt; Int -&gt; IO Int
</span><a href="../../base/src/GHC.IO.Handle.Text.html#hGetBuf"><span class="hs-identifier hs-var">hGetBuf</span></a></span><span> </span><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793753"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793746"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793749"><span class="hs-identifier hs-var">filesize</span></a></span><span>
</span><span id="line-252"></span><span>  </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793747"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">/=</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793749"><span class="hs-identifier hs-var">filesize</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-253"></span><span>       </span><span class="annot"><span class="annottext">String -&gt; IO ()
forall a. HasCallStack =&gt; String -&gt; a
</span><a href="../../base/src/GHC.Err.html#error"><span class="hs-identifier hs-var">error</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.readBinMem: only read &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793747"><span class="hs-identifier hs-var">count</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot; bytes&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-254"></span><span>  </span><span class="annot"><span class="annottext">Handle -&gt; IO ()
</span><a href="../../base/src/GHC.IO.Handle.html#hClose"><span class="hs-identifier hs-var">hClose</span></a></span><span> </span><span class="annot"><span class="annottext">Handle
</span><a href="#local-6989586621680793753"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-255"></span><span>  </span><span id="local-6989586621680793742"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793742"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinArray -&gt; IO (IORef BinArray)
forall a. a -&gt; IO (IORef a)
</span><a href="../../base/src/GHC.IORef.html#newIORef"><span class="hs-identifier hs-var">newIORef</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793748"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-256"></span><span>  </span><span id="local-6989586621680793741"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793741"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-257"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793741"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-258"></span><span>  </span><span id="local-6989586621680793740"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793740"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-259"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793740"><span class="hs-identifier hs-var">sz_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793749"><span class="hs-identifier hs-var">filesize</span></a></span><span>
</span><span id="line-260"></span><span>  </span><span class="annot"><span class="annottext">BinHandle -&gt; IO BinHandle
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UserData -&gt; FastMutInt -&gt; FastMutInt -&gt; IORef BinArray -&gt; BinHandle
</span><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-var">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
forall a. a
</span><a href="GHC.Utils.Binary.html#noUserData"><span class="hs-identifier hs-var">noUserData</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793741"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793740"><span class="hs-identifier hs-var">sz_r</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793742"><span class="hs-identifier hs-var">arr_r</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-261"></span><span>
</span><span id="line-262"></span><span class="hs-comment">-- expand the size of the array to include a specified offset</span><span>
</span><span id="line-263"></span><span class="annot"><a href="GHC.Utils.Binary.html#expandBin"><span class="hs-identifier hs-type">expandBin</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-264"></span><span id="expandBin"><span class="annot"><span class="annottext">expandBin :: BinHandle -&gt; Int -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#expandBin"><span class="hs-identifier hs-var hs-var">expandBin</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793739"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793739"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span id="local-6989586621680793738"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793738"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793737"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793737"><span class="hs-identifier hs-var">off</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-265"></span><span>   </span><span class="hs-glyph">!</span><span id="local-6989586621680793736"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793736"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793739"><span class="hs-identifier hs-var">sz_r</span></a></span><span>
</span><span id="line-266"></span><span>   </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793735"><span class="annot"><span class="annottext">sz' :: Int
</span><a href="#local-6989586621680793735"><span class="hs-identifier hs-var hs-var">sz'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621680793734"><span class="hs-identifier hs-var">getSize</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793736"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-267"></span><span>   </span><span id="local-6989586621680793733"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793733"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793738"><span class="hs-identifier hs-var">arr_r</span></a></span><span>
</span><span id="line-268"></span><span>   </span><span id="local-6989586621680793732"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793732"><span class="hs-identifier hs-var">arr'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IO BinArray
forall a. Int -&gt; IO (ForeignPtr a)
</span><a href="../../base/src/GHC.ForeignPtr.html#mallocForeignPtrBytes"><span class="hs-identifier hs-var">mallocForeignPtrBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793735"><span class="hs-identifier hs-var">sz'</span></a></span><span>
</span><span id="line-269"></span><span>   </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#withForeignPtr"><span class="hs-identifier hs-var">withForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793733"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793731"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793731"><span class="hs-identifier hs-var">old</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-270"></span><span>     </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#withForeignPtr"><span class="hs-identifier hs-var">withForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793732"><span class="hs-identifier hs-var">arr'</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793730"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793730"><span class="hs-identifier hs-var">new</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-271"></span><span>       </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
forall a. Ptr a -&gt; Ptr a -&gt; Int -&gt; IO ()
</span><a href="../../base/src/Foreign.Marshal.Utils.html#copyBytes"><span class="hs-identifier hs-var">copyBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793730"><span class="hs-identifier hs-var">new</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793731"><span class="hs-identifier hs-var">old</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793736"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-272"></span><span>   </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793739"><span class="hs-identifier hs-var">sz_r</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793735"><span class="hs-identifier hs-var">sz'</span></a></span><span>
</span><span id="line-273"></span><span>   </span><span class="annot"><span class="annottext">IORef BinArray -&gt; BinArray -&gt; IO ()
forall a. IORef a -&gt; a -&gt; IO ()
</span><a href="../../base/src/GHC.IORef.html#writeIORef"><span class="hs-identifier hs-var">writeIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793738"><span class="hs-identifier hs-var">arr_r</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793732"><span class="hs-identifier hs-var">arr'</span></a></span><span>
</span><span id="line-274"></span><span>   </span><span class="hs-keyword">where</span><span>
</span><span id="line-275"></span><span>    </span><span class="annot"><a href="#local-6989586621680793734"><span class="hs-identifier hs-type">getSize</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-276"></span><span>    </span><span id="local-6989586621680793734"><span class="annot"><span class="annottext">getSize :: Int -&gt; Int
</span><a href="#local-6989586621680793734"><span class="hs-identifier hs-var hs-var">getSize</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793728"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793728"><span class="hs-identifier hs-var">sz</span></a></span></span><span>
</span><span id="line-277"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793728"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793737"><span class="hs-identifier hs-var">off</span></a></span><span>
</span><span id="line-278"></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793728"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-279"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span>
</span><span id="line-280"></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int
</span><a href="#local-6989586621680793734"><span class="hs-identifier hs-var">getSize</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793728"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2A"><span class="hs-operator hs-var">*</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span class="hs-special">)</span><span>
</span><span id="line-281"></span><span>
</span><span id="line-282"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-283"></span><span class="hs-comment">-- Low-level reading/writing of bytes</span><span>
</span><span id="line-284"></span><span>
</span><span id="line-285"></span><span class="hs-comment">-- | Takes a size and action writing up to @size@ bytes.</span><span>
</span><span id="line-286"></span><span class="hs-comment">--   After the action has run advance the index to the buffer</span><span>
</span><span id="line-287"></span><span class="hs-comment">--   by size bytes.</span><span>
</span><span id="line-288"></span><span class="annot"><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-type">putPrim</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-289"></span><span id="putPrim"><span class="annot"><span class="annottext">putPrim :: BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var hs-var">putPrim</span></a></span></span><span> </span><span id="local-6989586621680793725"><span class="annot"><span class="annottext">h :: BinHandle
</span><a href="#local-6989586621680793725"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793724"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793724"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span id="local-6989586621680793723"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793723"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span id="local-6989586621680793722"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793722"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680793721"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793721"><span class="hs-identifier hs-var">size</span></a></span></span><span> </span><span id="local-6989586621680793720"><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO ()
</span><a href="#local-6989586621680793720"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-290"></span><span>  </span><span id="local-6989586621680793719"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793719"><span class="hs-identifier hs-var">ix</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793724"><span class="hs-identifier hs-var">ix_r</span></a></span><span>
</span><span id="line-291"></span><span>  </span><span id="local-6989586621680793718"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793718"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793723"><span class="hs-identifier hs-var">sz_r</span></a></span><span>
</span><span id="line-292"></span><span>  </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793719"><span class="hs-identifier hs-var">ix</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793721"><span class="hs-identifier hs-var">size</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793718"><span class="hs-identifier hs-var">sz</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-293"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#expandBin"><span class="hs-identifier hs-var">expandBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793725"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793719"><span class="hs-identifier hs-var">ix</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793721"><span class="hs-identifier hs-var">size</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-294"></span><span>  </span><span id="local-6989586621680793716"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793716"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793722"><span class="hs-identifier hs-var">arr_r</span></a></span><span>
</span><span id="line-295"></span><span>  </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793716"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ()) -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793715"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793715"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO ()
</span><a href="#local-6989586621680793720"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793715"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Ptr Word8
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="../../base/src/GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793719"><span class="hs-identifier hs-var">ix</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-296"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793724"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793719"><span class="hs-identifier hs-var">ix</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793721"><span class="hs-identifier hs-var">size</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-297"></span><span>
</span><span id="line-298"></span><span class="hs-comment">-- -- | Similar to putPrim but advances the index by the actual number of</span><span>
</span><span id="line-299"></span><span class="hs-comment">-- -- bytes written.</span><span>
</span><span id="line-300"></span><span class="hs-comment">-- putPrimMax :: BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO Int) -&gt; IO ()</span><span>
</span><span id="line-301"></span><span class="hs-comment">-- putPrimMax h@(BinMem _ ix_r sz_r arr_r) size f = do</span><span>
</span><span id="line-302"></span><span class="hs-comment">--   ix &lt;- readFastMutInt ix_r</span><span>
</span><span id="line-303"></span><span class="hs-comment">--   sz &lt;- readFastMutInt sz_r</span><span>
</span><span id="line-304"></span><span class="hs-comment">--   when (ix + size &gt; sz) $</span><span>
</span><span id="line-305"></span><span class="hs-comment">--     expandBin h (ix + size)</span><span>
</span><span id="line-306"></span><span class="hs-comment">--   arr &lt;- readIORef arr_r</span><span>
</span><span id="line-307"></span><span class="hs-comment">--   written &lt;- withForeignPtr arr $ \op -&gt; f (op `plusPtr` ix)</span><span>
</span><span id="line-308"></span><span class="hs-comment">--   writeFastMutInt ix_r (ix + written)</span><span>
</span><span id="line-309"></span><span>
</span><span id="line-310"></span><span id="local-6989586621680794837"><span class="annot"><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-type">getPrim</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794837"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794837"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-311"></span><span id="getPrim"><span class="annot"><span class="annottext">getPrim :: forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var hs-var">getPrim</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinMem"><span class="hs-identifier hs-type">BinMem</span></a></span><span> </span><span class="annot"><span class="annottext">UserData
</span><span class="hs-identifier">_</span></span><span> </span><span id="local-6989586621680793702"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793702"><span class="hs-identifier hs-var">ix_r</span></a></span></span><span> </span><span id="local-6989586621680793701"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793701"><span class="hs-identifier hs-var">sz_r</span></a></span></span><span> </span><span id="local-6989586621680793700"><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793700"><span class="hs-identifier hs-var">arr_r</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621680793699"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793699"><span class="hs-identifier hs-var">size</span></a></span></span><span> </span><span id="local-6989586621680793698"><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO a
</span><a href="#local-6989586621680793698"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-312"></span><span>  </span><span id="local-6989586621680793697"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793697"><span class="hs-identifier hs-var">ix</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793702"><span class="hs-identifier hs-var">ix_r</span></a></span><span>
</span><span id="line-313"></span><span>  </span><span id="local-6989586621680793696"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793696"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">FastMutInt -&gt; IO Int
</span><a href="GHC.Data.FastMutInt.html#readFastMutInt"><span class="hs-identifier hs-var">readFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793701"><span class="hs-identifier hs-var">sz_r</span></a></span><span>
</span><span id="line-314"></span><span>  </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/GHC.Base.html#when"><span class="hs-identifier hs-var">when</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793697"><span class="hs-identifier hs-var">ix</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793699"><span class="hs-identifier hs-var">size</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;</span></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793696"><span class="hs-identifier hs-var">sz</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-315"></span><span>      </span><span class="annot"><span class="annottext">IOError -&gt; IO ()
forall a. IOError -&gt; IO a
</span><a href="../../base/src/GHC.IO.Exception.html#ioError"><span class="hs-identifier hs-var">ioError</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IOErrorType -&gt; String -&gt; Maybe Handle -&gt; Maybe String -&gt; IOError
</span><a href="../../base/src/System.IO.Error.html#mkIOError"><span class="hs-identifier hs-var">mkIOError</span></a></span><span> </span><span class="annot"><span class="annottext">IOErrorType
</span><a href="../../base/src/System.IO.Error.html#eofErrorType"><span class="hs-identifier hs-var">eofErrorType</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Data.Binary.getPrim&quot;</span></span><span> </span><span class="annot"><span class="annottext">Maybe Handle
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe String
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-316"></span><span>  </span><span id="local-6989586621680793694"><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793694"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IORef BinArray -&gt; IO BinArray
forall a. IORef a -&gt; IO a
</span><a href="../../base/src/GHC.IORef.html#readIORef"><span class="hs-identifier hs-var">readIORef</span></a></span><span> </span><span class="annot"><span class="annottext">IORef BinArray
</span><a href="#local-6989586621680793700"><span class="hs-identifier hs-var">arr_r</span></a></span><span>
</span><span id="line-317"></span><span>  </span><span id="local-6989586621680793693"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793693"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinArray -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
forall a b. ForeignPtr a -&gt; (Ptr a -&gt; IO b) -&gt; IO b
</span><a href="../../base/src/GHC.ForeignPtr.html#unsafeWithForeignPtr"><span class="hs-identifier hs-var">unsafeWithForeignPtr</span></a></span><span> </span><span class="annot"><span class="annottext">BinArray
</span><a href="#local-6989586621680793694"><span class="hs-identifier hs-var">arr</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO a) -&gt; IO a) -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680793692"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793692"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO a
</span><a href="#local-6989586621680793698"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793692"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Ptr Word8
forall a b. Ptr a -&gt; Int -&gt; Ptr b
</span><a href="../../base/src/GHC.Ptr.html#plusPtr"><span class="hs-operator hs-var">`plusPtr`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793697"><span class="hs-identifier hs-var">ix</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-318"></span><span>    </span><span class="hs-comment">-- This is safe WRT #17760 as we we guarantee that the above line doesn't</span><span>
</span><span id="line-319"></span><span>    </span><span class="hs-comment">-- diverge</span><span>
</span><span id="line-320"></span><span>  </span><span class="annot"><span class="annottext">FastMutInt -&gt; Int -&gt; IO ()
</span><a href="GHC.Data.FastMutInt.html#writeFastMutInt"><span class="hs-identifier hs-var">writeFastMutInt</span></a></span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680793702"><span class="hs-identifier hs-var">ix_r</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793697"><span class="hs-identifier hs-var">ix</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793699"><span class="hs-identifier hs-var">size</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-321"></span><span>  </span><span class="annot"><span class="annottext">a -&gt; IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793693"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-322"></span><span>
</span><span id="line-323"></span><span class="annot"><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-type">putWord8</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-324"></span><span id="putWord8"><span class="annot"><span class="annottext">putWord8 :: BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var hs-var">putWord8</span></a></span></span><span> </span><span id="local-6989586621680793690"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793690"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793689"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793689"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793690"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793688"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793688"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#poke"><span class="hs-identifier hs-var">poke</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793688"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793689"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-325"></span><span>
</span><span id="line-326"></span><span class="annot"><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-type">getWord8</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-327"></span><span id="getWord8"><span class="annot"><span class="annottext">getWord8 :: BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var hs-var">getWord8</span></a></span></span><span> </span><span id="local-6989586621680793685"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793685"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO Word8) -&gt; IO Word8
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793685"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peek"><span class="hs-identifier hs-var">peek</span></a></span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span class="annot"><a href="GHC.Utils.Binary.html#putWord16"><span class="hs-identifier hs-type">putWord16</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-330"></span><span id="putWord16"><span class="annot"><span class="annottext">putWord16 :: BinHandle -&gt; Word16 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord16"><span class="hs-identifier hs-var hs-var">putWord16</span></a></span></span><span> </span><span id="local-6989586621680793682"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793682"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span id="local-6989586621680793681"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793681"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793682"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793680"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793680"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-331"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793680"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793681"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int -&gt; Word16
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-332"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793680"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793681"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16 -&gt; Word16
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-333"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-334"></span><span>
</span><span id="line-335"></span><span class="annot"><a href="GHC.Utils.Binary.html#getWord16"><span class="hs-identifier hs-type">getWord16</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span>
</span><span id="line-336"></span><span id="getWord16"><span class="annot"><span class="annottext">getWord16 :: BinHandle -&gt; IO Word16
</span><a href="GHC.Utils.Binary.html#getWord16"><span class="hs-identifier hs-var hs-var">getWord16</span></a></span></span><span> </span><span id="local-6989586621680793675"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793675"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO Word16) -&gt; IO Word16
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793675"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793674"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793674"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-337"></span><span>  </span><span id="local-6989586621680793673"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793673"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word16) -&gt; IO Word8 -&gt; IO Word16
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793674"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-338"></span><span>  </span><span id="local-6989586621680793671"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793671"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word16) -&gt; IO Word8 -&gt; IO Word16
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793674"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-339"></span><span>  </span><span class="annot"><span class="annottext">Word16 -&gt; IO Word16
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; IO Word16) -&gt; Word16 -&gt; IO Word16
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793673"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Int -&gt; Word16
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; Word16 -&gt; Word16
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793671"><span class="hs-identifier hs-var">w1</span></a></span><span>
</span><span id="line-340"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-341"></span><span>
</span><span id="line-342"></span><span class="annot"><a href="GHC.Utils.Binary.html#putWord32"><span class="hs-identifier hs-type">putWord32</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-343"></span><span id="putWord32"><span class="annot"><span class="annottext">putWord32 :: BinHandle -&gt; Word32 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord32"><span class="hs-identifier hs-var hs-var">putWord32</span></a></span></span><span> </span><span id="local-6989586621680793666"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793666"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span id="local-6989586621680793665"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793665"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793666"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793664"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793664"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-344"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793664"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793665"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-345"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793664"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793665"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-346"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793664"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793665"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-347"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793664"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793665"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-348"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-349"></span><span>
</span><span id="line-350"></span><span class="annot"><a href="GHC.Utils.Binary.html#getWord32"><span class="hs-identifier hs-type">getWord32</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span>
</span><span id="line-351"></span><span id="getWord32"><span class="annot"><span class="annottext">getWord32 :: BinHandle -&gt; IO Word32
</span><a href="GHC.Utils.Binary.html#getWord32"><span class="hs-identifier hs-var hs-var">getWord32</span></a></span></span><span> </span><span id="local-6989586621680793662"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793662"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO Word32) -&gt; IO Word32
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793662"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793661"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793661"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-352"></span><span>  </span><span id="local-6989586621680793660"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793660"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word32) -&gt; IO Word8 -&gt; IO Word32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793661"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-353"></span><span>  </span><span id="local-6989586621680793659"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793659"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word32) -&gt; IO Word8 -&gt; IO Word32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793661"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-354"></span><span>  </span><span id="local-6989586621680793658"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793658"><span class="hs-identifier hs-var">w2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word32) -&gt; IO Word8 -&gt; IO Word32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793661"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span>
</span><span id="line-355"></span><span>  </span><span id="local-6989586621680793657"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793657"><span class="hs-identifier hs-var">w3</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word32) -&gt; IO Word8 -&gt; IO Word32
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793661"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span>
</span><span id="line-356"></span><span>
</span><span id="line-357"></span><span>  </span><span class="annot"><span class="annottext">Word32 -&gt; IO Word32
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; IO Word32) -&gt; Word32 -&gt; IO Word32
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793660"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-358"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793659"><span class="hs-identifier hs-var">w1</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-359"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793658"><span class="hs-identifier hs-var">w2</span></a></span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; Int -&gt; Word32
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span>  </span><span class="annot"><span class="annottext">Word32 -&gt; Word32 -&gt; Word32
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-360"></span><span>            </span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793657"><span class="hs-identifier hs-var">w3</span></a></span><span>
</span><span id="line-361"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-362"></span><span>
</span><span id="line-363"></span><span class="annot"><a href="GHC.Utils.Binary.html#putWord64"><span class="hs-identifier hs-type">putWord64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-364"></span><span id="putWord64"><span class="annot"><span class="annottext">putWord64 :: BinHandle -&gt; Word64 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord64"><span class="hs-identifier hs-var hs-var">putWord64</span></a></span></span><span> </span><span id="local-6989586621680793655"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793655"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span id="local-6989586621680793654"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793655"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793653"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-365"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">56</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-366"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">48</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-367"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">40</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-368"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">32</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-369"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-370"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-371"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-372"></span><span>  </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; a -&gt; IO ()
</span><a href="../../base/src/Foreign.Storable.html#pokeElemOff"><span class="hs-identifier hs-var">pokeElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793653"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793654"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%26."><span class="hs-operator hs-var">.&amp;.</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><span class="hs-number">0xFF</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-373"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-374"></span><span>
</span><span id="line-375"></span><span class="annot"><a href="GHC.Utils.Binary.html#getWord64"><span class="hs-identifier hs-type">getWord64</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span>
</span><span id="line-376"></span><span id="getWord64"><span class="annot"><span class="annottext">getWord64 :: BinHandle -&gt; IO Word64
</span><a href="GHC.Utils.Binary.html#getWord64"><span class="hs-identifier hs-var hs-var">getWord64</span></a></span></span><span> </span><span id="local-6989586621680793651"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793651"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO Word64) -&gt; IO Word64
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793651"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680793650"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-377"></span><span>  </span><span id="local-6989586621680793649"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793649"><span class="hs-identifier hs-var">w0</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-378"></span><span>  </span><span id="local-6989586621680793648"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793648"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span>
</span><span id="line-379"></span><span>  </span><span id="local-6989586621680793647"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793647"><span class="hs-identifier hs-var">w2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">2</span></span><span>
</span><span id="line-380"></span><span>  </span><span id="local-6989586621680793646"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793646"><span class="hs-identifier hs-var">w3</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">3</span></span><span>
</span><span id="line-381"></span><span>  </span><span id="local-6989586621680793645"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793645"><span class="hs-identifier hs-var">w4</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">4</span></span><span>
</span><span id="line-382"></span><span>  </span><span id="local-6989586621680793644"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793644"><span class="hs-identifier hs-var">w5</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">5</span></span><span>
</span><span id="line-383"></span><span>  </span><span id="local-6989586621680793643"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793643"><span class="hs-identifier hs-var">w6</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span>
</span><span id="line-384"></span><span>  </span><span id="local-6989586621680793642"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793642"><span class="hs-identifier hs-var">w7</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; Word64) -&gt; IO Word8 -&gt; IO Word64
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; IO Word8
forall a. Storable a =&gt; Ptr a -&gt; Int -&gt; IO a
</span><a href="../../base/src/Foreign.Storable.html#peekElemOff"><span class="hs-identifier hs-var">peekElemOff</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680793650"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-385"></span><span>
</span><span id="line-386"></span><span>  </span><span class="annot"><span class="annottext">Word64 -&gt; IO Word64
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; IO Word64) -&gt; Word64 -&gt; IO Word64
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793649"><span class="hs-identifier hs-var">w0</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">56</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-387"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793648"><span class="hs-identifier hs-var">w1</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">48</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-388"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793647"><span class="hs-identifier hs-var">w2</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">40</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-389"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793646"><span class="hs-identifier hs-var">w3</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">32</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-390"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793645"><span class="hs-identifier hs-var">w4</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">24</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-391"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793644"><span class="hs-identifier hs-var">w5</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">16</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-392"></span><span>            </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793643"><span class="hs-identifier hs-var">w6</span></a></span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; Int -&gt; Word64
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span>  </span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Word64
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span>
</span><span id="line-393"></span><span>            </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793642"><span class="hs-identifier hs-var">w7</span></a></span><span>
</span><span id="line-394"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-395"></span><span>
</span><span id="line-396"></span><span class="annot"><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-type">putByte</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-397"></span><span id="putByte"><span class="annot"><span class="annottext">putByte :: BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var hs-var">putByte</span></a></span></span><span> </span><span id="local-6989586621680793641"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793641"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793640"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793640"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793641"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793640"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-398"></span><span>
</span><span id="line-399"></span><span class="annot"><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-type">getByte</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-400"></span><span id="getByte"><span class="annot"><span class="annottext">getByte :: BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var hs-var">getByte</span></a></span></span><span> </span><span id="local-6989586621680793639"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793639"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793639"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-401"></span><span>
</span><span id="line-402"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-403"></span><span class="hs-comment">-- Encode numbers in LEB128 encoding.</span><span>
</span><span id="line-404"></span><span class="hs-comment">-- Requires one byte of space per 7 bits of data.</span><span>
</span><span id="line-405"></span><span class="hs-comment">--</span><span>
</span><span id="line-406"></span><span class="hs-comment">-- There are signed and unsigned variants.</span><span>
</span><span id="line-407"></span><span class="hs-comment">-- Do NOT use the unsigned one for signed values, at worst it will</span><span>
</span><span id="line-408"></span><span class="hs-comment">-- result in wrong results, at best it will lead to bad performance</span><span>
</span><span id="line-409"></span><span class="hs-comment">-- when coercing negative values to an unsigned type.</span><span>
</span><span id="line-410"></span><span class="hs-comment">--</span><span>
</span><span id="line-411"></span><span class="hs-comment">-- We mark them as SPECIALIZE as it's extremely critical that they get specialized</span><span>
</span><span id="line-412"></span><span class="hs-comment">-- to their specific types.</span><span>
</span><span id="line-413"></span><span class="hs-comment">--</span><span>
</span><span id="line-414"></span><span class="hs-comment">-- TODO: Each use of putByte performs a bounds check,</span><span>
</span><span id="line-415"></span><span class="hs-comment">--       we should use putPrimMax here. However it's quite hard to return</span><span>
</span><span id="line-416"></span><span class="hs-comment">--       the number of bytes written into putPrimMax without allocating an</span><span>
</span><span id="line-417"></span><span class="hs-comment">--       Int for it, while the code below does not allocate at all.</span><span>
</span><span id="line-418"></span><span class="hs-comment">--       So we eat the cost of the bounds check instead of increasing allocations</span><span>
</span><span id="line-419"></span><span class="hs-comment">--       for now.</span><span>
</span><span id="line-420"></span><span>
</span><span id="line-421"></span><span class="hs-comment">-- Unsigned numbers</span><span>
</span><span id="line-422"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Word</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-423"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-424"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-425"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-426"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Int</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-427"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-428"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-429"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-pragma hs-type">putULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-430"></span><span class="annot"><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier hs-type">putULEB128</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621680794760"><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#FiniteBits"><span class="hs-identifier hs-type">FiniteBits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-431"></span><span id="putULEB128"><span class="annot"><span class="annottext">putULEB128 :: forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier hs-var hs-var">putULEB128</span></a></span></span><span> </span><span id="local-6989586621680793618"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793618"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793617"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793617"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span class="hs-cpp">
#if defined(DEBUG)
</span><span>    </span><span class="hs-special">(</span><span class="hs-keyword">if</span><span> </span><span class="hs-identifier">w</span><span> </span><span class="hs-operator">&lt;</span><span> </span><span class="hs-number">0</span><span> </span><span class="hs-keyword">then</span><span> </span><span class="hs-identifier">panic</span><span> </span><span class="hs-string">&quot;putULEB128: Signed number&quot;</span><span> </span><span class="hs-keyword">else</span><span> </span><span class="hs-identifier">id</span><span class="hs-special">)</span><span> </span><span class="hs-operator">$</span><span class="hs-cpp">
#endif
</span><span>    </span><span class="annot"><span class="annottext">a -&gt; IO ()
</span><a href="#local-6989586621680793616"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793617"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-436"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-437"></span><span>    </span><span class="annot"><a href="#local-6989586621680793616"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-438"></span><span>    </span><span id="local-6989586621680793616"><span class="annot"><span class="annottext">go :: a -&gt; IO ()
</span><a href="#local-6989586621680793616"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680793615"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793615"><span class="hs-identifier hs-var">w</span></a></span></span><span>
</span><span id="line-439"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793615"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">127</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794760"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-440"></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793618"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793615"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-441"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-442"></span><span>        </span><span class="hs-comment">-- bit 7 (8th bit) indicates more to come.</span><span>
</span><span id="line-443"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793614"><span class="annot"><span class="annottext">byte :: Word8
</span><a href="#local-6989586621680793614"><span class="hs-identifier hs-var hs-var">byte</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Word8
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#setBit"><span class="hs-identifier hs-var">setBit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793615"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-444"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793618"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793614"><span class="hs-identifier hs-var">byte</span></a></span><span>
</span><span id="line-445"></span><span>        </span><span class="annot"><span class="annottext">a -&gt; IO ()
</span><a href="#local-6989586621680793616"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793615"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#unsafeShiftR"><span class="hs-operator hs-var">`unsafeShiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span>
</span><span id="line-446"></span><span>
</span><span id="line-447"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-pragma hs-type">Word</span></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-448"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-449"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-450"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-451"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-pragma hs-type">Int</span></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-452"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-453"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-454"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-pragma hs-type">getULEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-455"></span><span class="annot"><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier hs-type">getULEB128</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621680794755"><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#FiniteBits"><span class="hs-identifier hs-type">FiniteBits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-456"></span><span id="getULEB128"><span class="annot"><span class="annottext">getULEB128 :: forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier hs-var hs-var">getULEB128</span></a></span></span><span> </span><span id="local-6989586621680793595"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793595"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-457"></span><span>    </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; IO a
</span><a href="#local-6989586621680793594"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span>
</span><span id="line-458"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-459"></span><span>    </span><span class="annot"><a href="#local-6989586621680793594"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-460"></span><span>    </span><span id="local-6989586621680793594"><span class="annot"><span class="annottext">go :: Int -&gt; a -&gt; IO a
</span><a href="#local-6989586621680793594"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680793593"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793593"><span class="hs-identifier hs-var">shift</span></a></span></span><span> </span><span id="local-6989586621680793592"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793592"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-461"></span><span>        </span><span id="local-6989586621680793591"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793591"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793595"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-462"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793590"><span class="annot"><span class="annottext">hasMore :: Bool
</span><a href="#local-6989586621680793590"><span class="hs-identifier hs-var hs-var">hasMore</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Bool
forall a. Bits a =&gt; a -&gt; Int -&gt; Bool
</span><a href="../../base/src/Data.Bits.html#testBit"><span class="hs-identifier hs-var">testBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793591"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-463"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793588"><span class="annot"><span class="annottext">val :: a
</span><a href="#local-6989586621680793588"><span class="hs-identifier hs-var hs-var">val</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793592"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#clearBit"><span class="hs-identifier hs-var">clearBit</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793591"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#unsafeShiftL"><span class="hs-operator hs-var">`unsafeShiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793593"><span class="hs-identifier hs-var">shift</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794755"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-464"></span><span>        </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793590"><span class="hs-identifier hs-var">hasMore</span></a></span><span>
</span><span id="line-465"></span><span>            </span><span class="hs-keyword">then</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-466"></span><span>                </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; IO a
</span><a href="#local-6989586621680793594"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793593"><span class="hs-identifier hs-var">shift</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793588"><span class="hs-identifier hs-var">val</span></a></span><span>
</span><span id="line-467"></span><span>            </span><span class="hs-keyword">else</span><span>
</span><span id="line-468"></span><span>                </span><span class="annot"><span class="annottext">a -&gt; IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; IO a) -&gt; a -&gt; IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793588"><span class="hs-identifier hs-var">val</span></a></span><span>
</span><span id="line-469"></span><span>
</span><span id="line-470"></span><span class="hs-comment">-- Signed numbers</span><span>
</span><span id="line-471"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Word</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-472"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-473"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-474"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-475"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">Int</span></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-476"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-477"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-478"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-pragma hs-type">putSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="hs-pragma">(</span><span class="hs-pragma">)</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-479"></span><span class="annot"><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier hs-type">putSLEB128</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621680794753"><span class="annot"><a href="#local-6989586621680794753"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794753"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#Bits"><span class="hs-identifier hs-type">Bits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794753"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794753"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-480"></span><span id="putSLEB128"><span class="annot"><span class="annottext">putSLEB128 :: forall a. (Integral a, Bits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier hs-var hs-var">putSLEB128</span></a></span></span><span> </span><span id="local-6989586621680793565"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793565"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793564"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793564"><span class="hs-identifier hs-var">initial</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; IO ()
</span><a href="#local-6989586621680793563"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793564"><span class="hs-identifier hs-var">initial</span></a></span><span>
</span><span id="line-481"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-482"></span><span>    </span><span class="annot"><a href="#local-6989586621680793563"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794753"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-483"></span><span>    </span><span id="local-6989586621680793563"><span class="annot"><span class="annottext">go :: a -&gt; IO ()
</span><a href="#local-6989586621680793563"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680793562"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793562"><span class="hs-identifier hs-var">val</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-484"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793561"><span class="annot"><span class="annottext">byte :: Word8
</span><a href="#local-6989586621680793561"><span class="hs-identifier hs-var hs-var">byte</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#clearBit"><span class="hs-identifier hs-var">clearBit</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793562"><span class="hs-identifier hs-var">val</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-485"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793560"><span class="annot"><span class="annottext">val' :: a
</span><a href="#local-6989586621680793560"><span class="hs-identifier hs-var hs-var">val'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793562"><span class="hs-identifier hs-var">val</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#unsafeShiftR"><span class="hs-operator hs-var">`unsafeShiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-486"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793559"><span class="annot"><span class="annottext">signBit :: Bool
</span><a href="#local-6989586621680793559"><span class="hs-identifier hs-var hs-var">signBit</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Bool
forall a. Bits a =&gt; a -&gt; Int -&gt; Bool
</span><a href="../../base/src/Data.Bits.html#testBit"><span class="hs-identifier hs-var">testBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793561"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span>
</span><span id="line-487"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793558"><span class="annot"><span class="annottext">done :: Bool
</span><a href="#local-6989586621680793558"><span class="hs-identifier hs-var hs-var">done</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-488"></span><span>                </span><span class="hs-comment">-- Unsigned value, val' == 0 and last value can</span><span>
</span><span id="line-489"></span><span>                </span><span class="hs-comment">-- be discriminated from a negative number.</span><span>
</span><span id="line-490"></span><span>                </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793560"><span class="hs-identifier hs-var">val'</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool
</span><span class="hs-identifier hs-var">not</span></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793559"><span class="hs-identifier hs-var">signBit</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">||</span></span><span>
</span><span id="line-491"></span><span>                </span><span class="hs-comment">-- Signed value,</span><span>
</span><span id="line-492"></span><span>                 </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793560"><span class="hs-identifier hs-var">val'</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="hs-glyph">-</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793559"><span class="hs-identifier hs-var">signBit</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-493"></span><span>
</span><span id="line-494"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793554"><span class="annot"><span class="annottext">byte' :: Word8
</span><a href="#local-6989586621680793554"><span class="hs-identifier hs-var hs-var">byte'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793558"><span class="hs-identifier hs-var">done</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793561"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Word8
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#setBit"><span class="hs-identifier hs-var">setBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793561"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-495"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793565"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793554"><span class="hs-identifier hs-var">byte'</span></a></span><span>
</span><span id="line-496"></span><span>
</span><span id="line-497"></span><span>        </span><span class="annot"><span class="annottext">Bool -&gt; IO () -&gt; IO ()
forall (f :: * -&gt; *). Applicative f =&gt; Bool -&gt; f () -&gt; f ()
</span><a href="../../base/src/Control.Monad.html#unless"><span class="hs-identifier hs-var">unless</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793558"><span class="hs-identifier hs-var">done</span></a></span><span> </span><span class="annot"><span class="annottext">(IO () -&gt; IO ()) -&gt; IO () -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; IO ()
</span><a href="#local-6989586621680793563"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793560"><span class="hs-identifier hs-var">val'</span></a></span><span>
</span><span id="line-498"></span><span>
</span><span id="line-499"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-pragma hs-type">Word</span></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-500"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-pragma hs-type">Word64</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-501"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-pragma hs-type">Word32</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-502"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-pragma hs-type">Word16</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-503"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-pragma hs-type">Int</span></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-504"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-pragma hs-type">Int64</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-505"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-pragma hs-type">Int32</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-506"></span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-pragma hs-type">getSLEB128</span></a></span><span> </span><span class="hs-pragma">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-pragma hs-type">BinHandle</span></a></span><span> </span><span class="hs-pragma">-&gt;</span><span> </span><span class="annot"><span class="hs-pragma hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-pragma hs-type">Int16</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-507"></span><span class="annot"><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier hs-type">getSLEB128</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621680794751"><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span></span><span class="hs-operator">.</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Bits.html#FiniteBits"><span class="hs-identifier hs-type">FiniteBits</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-508"></span><span id="getSLEB128"><span class="annot"><span class="annottext">getSLEB128 :: forall a. (Show a, Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier hs-var hs-var">getSLEB128</span></a></span></span><span> </span><span id="local-6989586621680793526"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793526"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-509"></span><span>    </span><span class="hs-special">(</span><span id="local-6989586621680793525"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793525"><span class="hs-identifier hs-var">val</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793524"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793524"><span class="hs-identifier hs-var">shift</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793523"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793523"><span class="hs-identifier hs-var">signed</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; IO (a, Int, Bool)
</span><a href="#local-6989586621680793522"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span>
</span><span id="line-510"></span><span>    </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793523"><span class="hs-identifier hs-var">signed</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793524"><span class="hs-identifier hs-var">shift</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int
forall b. FiniteBits b =&gt; b -&gt; Int
</span><a href="../../base/src/Data.Bits.html#finiteBitSize"><span class="hs-identifier hs-var">finiteBitSize</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793525"><span class="hs-identifier hs-var">val</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-511"></span><span>        </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">a -&gt; IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; IO a) -&gt; a -&gt; IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; a
forall a. Bits a =&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#complement"><span class="hs-identifier hs-var">complement</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#unsafeShiftL"><span class="hs-operator hs-var">`unsafeShiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793524"><span class="hs-identifier hs-var">shift</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793525"><span class="hs-identifier hs-var">val</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-512"></span><span>        </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">a -&gt; IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793525"><span class="hs-identifier hs-var">val</span></a></span><span>
</span><span id="line-513"></span><span>    </span><span class="hs-keyword">where</span><span>
</span><span id="line-514"></span><span>        </span><span class="annot"><a href="#local-6989586621680793522"><span class="hs-identifier hs-type">go</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span class="hs-special">)</span><span>
</span><span id="line-515"></span><span>        </span><span id="local-6989586621680793522"><span class="annot"><span class="annottext">go :: Int -&gt; a -&gt; IO (a, Int, Bool)
</span><a href="#local-6989586621680793522"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621680793518"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793518"><span class="hs-identifier hs-var">shift</span></a></span></span><span> </span><span id="local-6989586621680793517"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793517"><span class="hs-identifier hs-var">val</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-516"></span><span>            </span><span id="local-6989586621680793516"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793516"><span class="hs-identifier hs-var">byte</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793526"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-517"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793515"><span class="annot"><span class="annottext">byteVal :: a
</span><a href="#local-6989586621680793515"><span class="hs-identifier hs-var hs-var">byteVal</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Word8
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#clearBit"><span class="hs-identifier hs-var">clearBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793516"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794751"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-518"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793514"><span class="annot"><span class="annottext">val' :: a
</span><a href="#local-6989586621680793514"><span class="hs-identifier hs-var hs-var">val'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793517"><span class="hs-identifier hs-var">val</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793515"><span class="hs-identifier hs-var">byteVal</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#unsafeShiftL"><span class="hs-operator hs-var">`unsafeShiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793518"><span class="hs-identifier hs-var">shift</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-519"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793513"><span class="annot"><span class="annottext">more :: Bool
</span><a href="#local-6989586621680793513"><span class="hs-identifier hs-var hs-var">more</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Bool
forall a. Bits a =&gt; a -&gt; Int -&gt; Bool
</span><a href="../../base/src/Data.Bits.html#testBit"><span class="hs-identifier hs-var">testBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793516"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-520"></span><span>            </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793512"><span class="annot"><span class="annottext">shift' :: Int
</span><a href="#local-6989586621680793512"><span class="hs-identifier hs-var hs-var">shift'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793518"><span class="hs-identifier hs-var">shift</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">7</span></span><span>
</span><span id="line-521"></span><span>            </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793513"><span class="hs-identifier hs-var">more</span></a></span><span>
</span><span id="line-522"></span><span>                </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">Int -&gt; a -&gt; IO (a, Int, Bool)
</span><a href="#local-6989586621680793522"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793512"><span class="hs-identifier hs-var">shift'</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793514"><span class="hs-identifier hs-var">val'</span></a></span><span>
</span><span id="line-523"></span><span>                </span><span class="hs-keyword">else</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-524"></span><span>                    </span><span class="hs-keyword">let</span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793511"><span class="annot"><span class="annottext">signed :: Bool
</span><a href="#local-6989586621680793511"><span class="hs-identifier hs-var hs-var">signed</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int -&gt; Bool
forall a. Bits a =&gt; a -&gt; Int -&gt; Bool
</span><a href="../../base/src/Data.Bits.html#testBit"><span class="hs-identifier hs-var">testBit</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793516"><span class="hs-identifier hs-var">byte</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">6</span></span><span>
</span><span id="line-525"></span><span>                    </span><span class="annot"><span class="annottext">(a, Int, Bool) -&gt; IO (a, Int, Bool)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793514"><span class="hs-identifier hs-var">val'</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793512"><span class="hs-identifier hs-var">shift'</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793511"><span class="hs-identifier hs-var">signed</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-526"></span><span>
</span><span id="line-527"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-528"></span><span class="hs-comment">-- Fixed length encoding instances</span><span>
</span><span id="line-529"></span><span>
</span><span id="line-530"></span><span class="hs-comment">-- Sometimes words are used to represent a certain bit pattern instead</span><span>
</span><span id="line-531"></span><span class="hs-comment">-- of a number. Using FixedLengthEncoding we will write the pattern as</span><span>
</span><span id="line-532"></span><span class="hs-comment">-- is to the interface file without the variable length encoding we usually</span><span>
</span><span id="line-533"></span><span class="hs-comment">-- apply.</span><span>
</span><span id="line-534"></span><span>
</span><span id="line-535"></span><span class="hs-comment">-- | Encode the argument in it's full length. This is different from many default</span><span>
</span><span id="line-536"></span><span class="hs-comment">-- binary instances which make no guarantee about the actual encoding and</span><span>
</span><span id="line-537"></span><span class="hs-comment">-- might do things use variable length encoding.</span><span>
</span><span id="line-538"></span><span class="hs-keyword">newtype</span><span> </span><span id="FixedLengthEncoding"><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span></span><span> </span><span id="local-6989586621680794749"><span class="annot"><a href="#local-6989586621680794749"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="FixedLengthEncoding"><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span></span><span> </span><span class="hs-special">{</span><span> </span><span id="unFixedLength"><span class="annot"><span class="annottext">forall a. FixedLengthEncoding a -&gt; a
</span><a href="GHC.Utils.Binary.html#unFixedLength"><span class="hs-identifier hs-var hs-var">unFixedLength</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794749"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-539"></span><span>
</span><span id="line-540"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793506"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-541"></span><span>  </span><span id="local-6989586621680793504"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FixedLengthEncoding Word8 -&gt; IO ()
</span><a href="#local-6989586621680793504"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793503"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793503"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span id="local-6989586621680793502"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793502"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793503"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793502"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-542"></span><span>  </span><span id="local-6989586621680793500"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (FixedLengthEncoding Word8)
</span><a href="#local-6989586621680793500"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793499"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793499"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; FixedLengthEncoding Word8
forall a. a -&gt; FixedLengthEncoding a
</span><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; FixedLengthEncoding Word8)
-&gt; IO Word8 -&gt; IO (FixedLengthEncoding Word8)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793499"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-543"></span><span>
</span><span id="line-544"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793496"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-545"></span><span>  </span><span id="local-6989586621680793494"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FixedLengthEncoding Word16 -&gt; IO ()
</span><a href="#local-6989586621680793494"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793493"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793493"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span id="local-6989586621680793492"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793492"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word16 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord16"><span class="hs-identifier hs-var">putWord16</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793493"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621680793492"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-546"></span><span>  </span><span id="local-6989586621680793490"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (FixedLengthEncoding Word16)
</span><a href="#local-6989586621680793490"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793489"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793489"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word16 -&gt; FixedLengthEncoding Word16
forall a. a -&gt; FixedLengthEncoding a
</span><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><span class="annottext">(Word16 -&gt; FixedLengthEncoding Word16)
-&gt; IO Word16 -&gt; IO (FixedLengthEncoding Word16)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word16
</span><a href="GHC.Utils.Binary.html#getWord16"><span class="hs-identifier hs-var">getWord16</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793489"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-547"></span><span>
</span><span id="line-548"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793486"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-549"></span><span>  </span><span id="local-6989586621680793484"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FixedLengthEncoding Word32 -&gt; IO ()
</span><a href="#local-6989586621680793484"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793483"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793483"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span id="local-6989586621680793482"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793482"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word32 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord32"><span class="hs-identifier hs-var">putWord32</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793483"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793482"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-550"></span><span>  </span><span id="local-6989586621680793480"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (FixedLengthEncoding Word32)
</span><a href="#local-6989586621680793480"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793479"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793479"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word32 -&gt; FixedLengthEncoding Word32
forall a. a -&gt; FixedLengthEncoding a
</span><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><span class="annottext">(Word32 -&gt; FixedLengthEncoding Word32)
-&gt; IO Word32 -&gt; IO (FixedLengthEncoding Word32)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word32
</span><a href="GHC.Utils.Binary.html#getWord32"><span class="hs-identifier hs-var">getWord32</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793479"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-551"></span><span>
</span><span id="line-552"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793476"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-553"></span><span>  </span><span id="local-6989586621680793474"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FixedLengthEncoding Word64 -&gt; IO ()
</span><a href="#local-6989586621680793474"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793473"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793473"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-type">FixedLengthEncoding</span></a></span><span> </span><span id="local-6989586621680793472"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793472"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word64 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord64"><span class="hs-identifier hs-var">putWord64</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793473"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680793472"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-554"></span><span>  </span><span id="local-6989586621680793470"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (FixedLengthEncoding Word64)
</span><a href="#local-6989586621680793470"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793469"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793469"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Word64 -&gt; FixedLengthEncoding Word64
forall a. a -&gt; FixedLengthEncoding a
</span><a href="GHC.Utils.Binary.html#FixedLengthEncoding"><span class="hs-identifier hs-var">FixedLengthEncoding</span></a></span><span> </span><span class="annot"><span class="annottext">(Word64 -&gt; FixedLengthEncoding Word64)
-&gt; IO Word64 -&gt; IO (FixedLengthEncoding Word64)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word64
</span><a href="GHC.Utils.Binary.html#getWord64"><span class="hs-identifier hs-var">getWord64</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793469"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-555"></span><span>
</span><span id="line-556"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-557"></span><span class="hs-comment">-- Primitive Word writes</span><span>
</span><span id="line-558"></span><span>
</span><span id="line-559"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793466"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-560"></span><span>  </span><span id="local-6989586621680793464"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="#local-6989586621680793464"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793463"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793463"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">!</span><span id="local-6989586621680793462"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793462"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793463"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793462"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-561"></span><span>  </span><span id="local-6989586621680793461"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Word8
</span><a href="#local-6989586621680793461"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span>
</span><span id="line-562"></span><span>
</span><span id="line-563"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793458"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-564"></span><span>  </span><span id="local-6989586621680793454"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Word16 -&gt; IO ()
</span><a href="#local-6989586621680793454"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word16 -&gt; IO ()
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier hs-var">putULEB128</span></a></span><span>
</span><span id="line-565"></span><span>  </span><span id="local-6989586621680793451"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Word16
</span><a href="#local-6989586621680793451"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word16
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier hs-var">getULEB128</span></a></span><span>
</span><span id="line-566"></span><span>
</span><span id="line-567"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793448"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-568"></span><span>  </span><span id="local-6989586621680793444"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Word32 -&gt; IO ()
</span><a href="#local-6989586621680793444"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word32 -&gt; IO ()
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier hs-var">putULEB128</span></a></span><span>
</span><span id="line-569"></span><span>  </span><span id="local-6989586621680793441"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Word32
</span><a href="#local-6989586621680793441"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word32
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier hs-var">getULEB128</span></a></span><span>
</span><span id="line-570"></span><span>
</span><span id="line-571"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793438"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-572"></span><span>  </span><span id="local-6989586621680793434"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621680793434"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word64 -&gt; IO ()
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putULEB128"><span class="hs-identifier hs-var">putULEB128</span></a></span><span>
</span><span id="line-573"></span><span>  </span><span id="local-6989586621680793431"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Word64
</span><a href="#local-6989586621680793431"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word64
forall a. (Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getULEB128"><span class="hs-identifier hs-var">getULEB128</span></a></span><span>
</span><span id="line-574"></span><span>
</span><span id="line-575"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-576"></span><span class="hs-comment">-- Primitive Int writes</span><span>
</span><span id="line-577"></span><span>
</span><span id="line-578"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793428"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-identifier hs-type">Int8</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-579"></span><span>  </span><span id="local-6989586621680793422"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Int8 -&gt; IO ()
</span><a href="#local-6989586621680793422"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793421"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793421"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span id="local-6989586621680793420"><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621680793420"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793421"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int8 -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621680793420"><span class="hs-identifier hs-var">w</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-580"></span><span>  </span><span id="local-6989586621680793413"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Int8
</span><a href="#local-6989586621680793413"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793412"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793412"><span class="hs-identifier hs-var">h</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793411"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793411"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793412"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Int8 -&gt; IO Int8
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Int8 -&gt; IO Int8) -&gt; Int8 -&gt; IO Int8
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Int8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793411"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-glyph">::</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-581"></span><span>
</span><span id="line-582"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793408"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-583"></span><span>  </span><span id="local-6989586621680793404"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Int16 -&gt; IO ()
</span><a href="#local-6989586621680793404"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int16 -&gt; IO ()
forall a. (Integral a, Bits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier hs-var">putSLEB128</span></a></span><span>
</span><span id="line-584"></span><span>  </span><span id="local-6989586621680793400"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Int16
</span><a href="#local-6989586621680793400"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int16
forall a. (Show a, Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier hs-var">getSLEB128</span></a></span><span>
</span><span id="line-585"></span><span>
</span><span id="line-586"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793397"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-587"></span><span>  </span><span id="local-6989586621680793393"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Int32 -&gt; IO ()
</span><a href="#local-6989586621680793393"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int32 -&gt; IO ()
forall a. (Integral a, Bits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier hs-var">putSLEB128</span></a></span><span>
</span><span id="line-588"></span><span>  </span><span id="local-6989586621680793389"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Int32
</span><a href="#local-6989586621680793389"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int32
forall a. (Show a, Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier hs-var">getSLEB128</span></a></span><span>
</span><span id="line-589"></span><span>
</span><span id="line-590"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793386"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-591"></span><span>  </span><span id="local-6989586621680793382"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Int64 -&gt; IO ()
</span><a href="#local-6989586621680793382"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793381"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793381"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span id="local-6989586621680793380"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621680793380"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int64 -&gt; IO ()
forall a. (Integral a, Bits a) =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putSLEB128"><span class="hs-identifier hs-var">putSLEB128</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793381"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621680793380"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-592"></span><span>  </span><span id="local-6989586621680793376"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Int64
</span><a href="#local-6989586621680793376"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793375"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793375"><span class="hs-identifier hs-var">h</span></a></span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int64
forall a. (Show a, Integral a, FiniteBits a) =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getSLEB128"><span class="hs-identifier hs-var">getSLEB128</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793375"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-593"></span><span>
</span><span id="line-594"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-595"></span><span class="hs-comment">-- Instances for standard types</span><span>
</span><span id="line-596"></span><span>
</span><span id="line-597"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793372"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-598"></span><span>    </span><span id="local-6989586621680793369"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; () -&gt; IO ()
</span><a href="#local-6989586621680793369"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-599"></span><span>    </span><span id="local-6989586621680793367"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO ()
</span><a href="#local-6989586621680793367"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span class="annot"><span class="annottext">BinHandle
</span><span class="hs-identifier">_</span></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">() -&gt; IO ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-600"></span><span>
</span><span id="line-601"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793364"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-602"></span><span>    </span><span id="local-6989586621680793358"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Bool -&gt; IO ()
</span><a href="#local-6989586621680793358"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793357"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793357"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793356"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793356"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793357"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680793356"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-603"></span><span>    </span><span id="local-6989586621680793349"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Bool
</span><a href="#local-6989586621680793349"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span id="local-6989586621680793348"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793348"><span class="hs-identifier hs-var">bh</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793347"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793347"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793348"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; IO Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Bool -&gt; IO Bool) -&gt; Bool -&gt; IO Bool
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Bool
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793347"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-604"></span><span>
</span><span id="line-605"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793343"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-606"></span><span>    </span><span id="local-6989586621680793338"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Char -&gt; IO ()
</span><a href="#local-6989586621680793338"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span>  </span><span id="local-6989586621680793337"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793337"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793336"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621680793336"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word32 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793337"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; Int
</span><a href="../../base/src/GHC.Base.html#ord"><span class="hs-identifier hs-var">ord</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621680793336"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-607"></span><span>    </span><span id="local-6989586621680793330"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Char
</span><a href="#local-6989586621680793330"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span id="local-6989586621680793329"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793329"><span class="hs-identifier hs-var">bh</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793328"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793328"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word32
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793329"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Char -&gt; IO Char
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Char -&gt; IO Char) -&gt; Char -&gt; IO Char
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Char
</span><a href="../../base/src/GHC.Char.html#chr"><span class="hs-identifier hs-var">chr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680793328"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-608"></span><span>
</span><span id="line-609"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793325"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-610"></span><span>    </span><span id="local-6989586621680793319"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Int -&gt; IO ()
</span><a href="#local-6989586621680793319"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793318"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793318"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793317"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793317"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int64 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793318"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793317"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-611"></span><span>    </span><span id="local-6989586621680793311"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Int
</span><a href="#local-6989586621680793311"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span id="local-6989586621680793310"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793310"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-612"></span><span>        </span><span id="local-6989586621680793309"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621680793309"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int64
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793310"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-613"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; IO Int
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; IO Int) -&gt; Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621680793309"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-614"></span><span>
</span><span id="line-615"></span><span id="local-6989586621680794851"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793306"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794851"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621680794851"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-616"></span><span>    </span><span id="local-6989586621680793298"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; [a] -&gt; IO ()
</span><a href="#local-6989586621680793298"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793297"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793297"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793296"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680793296"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-617"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680793295"><span class="annot"><span class="annottext">len :: Int
</span><a href="#local-6989586621680793295"><span class="hs-identifier hs-var hs-var">len</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; Int
forall (t :: * -&gt; *) a. Foldable t =&gt; t a -&gt; Int
</span><a href="../../base/src/Data.Foldable.html#length"><span class="hs-identifier hs-var">length</span></a></span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680793296"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-618"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793297"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793295"><span class="hs-identifier hs-var">len</span></a></span><span>
</span><span id="line-619"></span><span>        </span><span class="annot"><span class="annottext">(a -&gt; IO ()) -&gt; [a] -&gt; IO ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793297"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680793296"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-620"></span><span>    </span><span id="local-6989586621680793281"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO [a]
</span><a href="#local-6989586621680793281"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793280"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793280"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-621"></span><span>        </span><span id="local-6989586621680793279"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793279"><span class="hs-identifier hs-var">len</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793280"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-comment">-- Int is variable length encoded so only</span><span>
</span><span id="line-622"></span><span>                                </span><span class="hs-comment">-- one byte for small lists.</span><span>
</span><span id="line-623"></span><span>        </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621680793278"><span class="annot"><span class="annottext">loop :: Int -&gt; IO [a]
</span><a href="#local-6989586621680793278"><span class="hs-identifier hs-var hs-var">loop</span></a></span></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; IO [a]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-624"></span><span>            </span><span class="annot"><a href="#local-6989586621680793278"><span class="hs-identifier hs-var">loop</span></a></span><span> </span><span id="local-6989586621680793277"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793277"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793276"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793276"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793280"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621680793275"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680793275"><span class="hs-keyword hs-var">as</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; IO [a]
</span><a href="#local-6989586621680793278"><span class="hs-identifier hs-var">loop</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793277"><span class="hs-identifier hs-var">n</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; IO [a]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793276"><span class="hs-identifier hs-var">a</span></a></span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; [a]
forall a. a -&gt; [a] -&gt; [a]
</span><span class="hs-glyph hs-var">:</span></span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621680793275"><span class="hs-keyword hs-var">as</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-625"></span><span>        </span><span class="annot"><span class="annottext">Int -&gt; IO [a]
</span><a href="#local-6989586621680793278"><span class="hs-identifier hs-var">loop</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680793279"><span class="hs-identifier hs-var">len</span></a></span></span><span>
</span><span id="line-626"></span><span>
</span><span id="line-627"></span><span id="local-6989586621680794739"><span id="local-6989586621680794740"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793272"><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ix.html#Ix"><span class="hs-identifier hs-type">Ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794740"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794740"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794739"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794740"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794739"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-628"></span><span>    </span><span id="local-6989586621680793267"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Array a b -&gt; IO ()
</span><a href="#local-6989586621680793267"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793266"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793266"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680793265"><span class="annot"><span class="annottext">Array a b
</span><a href="#local-6989586621680793265"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-629"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; (a, a) -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793266"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">((a, a) -&gt; IO ()) -&gt; (a, a) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Array a b -&gt; (a, a)
forall i e. Array i e -&gt; (i, i)
</span><a href="../../base/src/GHC.Arr.html#bounds"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">Array a b
</span><a href="#local-6989586621680793265"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-630"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; [b] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793266"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">([b] -&gt; IO ()) -&gt; [b] -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Array a b -&gt; [b]
forall i e. Array i e -&gt; [e]
</span><a href="../../base/src/GHC.Arr.html#elems"><span class="hs-identifier hs-var">elems</span></a></span><span> </span><span class="annot"><span class="annottext">Array a b
</span><a href="#local-6989586621680793265"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-631"></span><span>    </span><span id="local-6989586621680793256"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Array a b)
</span><a href="#local-6989586621680793256"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793255"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793255"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-632"></span><span>        </span><span id="local-6989586621680793254"><span class="annot"><span class="annottext">(a, a)
</span><a href="#local-6989586621680793254"><span class="hs-identifier hs-var">bounds</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (a, a)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793255"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-633"></span><span>        </span><span id="local-6989586621680793253"><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680793253"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [b]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793255"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-634"></span><span>        </span><span class="annot"><span class="annottext">Array a b -&gt; IO (Array a b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Array a b -&gt; IO (Array a b)) -&gt; Array a b -&gt; IO (Array a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">(a, a) -&gt; [b] -&gt; Array a b
forall i e. Ix i =&gt; (i, i) -&gt; [e] -&gt; Array i e
</span><a href="../../base/src/GHC.Arr.html#listArray"><span class="hs-identifier hs-var">listArray</span></a></span><span> </span><span class="annot"><span class="annottext">(a, a)
</span><a href="#local-6989586621680793254"><span class="hs-identifier hs-var">bounds</span></a></span><span> </span><span class="annot"><span class="annottext">[b]
</span><a href="#local-6989586621680793253"><span class="hs-identifier hs-var">xs</span></a></span></span></span><span>
</span><span id="line-635"></span><span>
</span><span id="line-636"></span><span id="local-6989586621680794737"><span id="local-6989586621680794738"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793249"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794738"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794737"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794738"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794737"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-637"></span><span>    </span><span id="local-6989586621680793244"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b) -&gt; IO ()
</span><a href="#local-6989586621680793244"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793243"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793243"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793242"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793242"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793241"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793241"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793243"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793242"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793243"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793241"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-638"></span><span>    </span><span id="local-6989586621680793235"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b)
</span><a href="#local-6989586621680793235"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793234"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793234"><span class="hs-identifier hs-var">bh</span></a></span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793233"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793233"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793234"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-639"></span><span>                       </span><span id="local-6989586621680793232"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793232"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793234"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-640"></span><span>                       </span><span class="annot"><span class="annottext">(a, b) -&gt; IO (a, b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793233"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793232"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-641"></span><span>
</span><span id="line-642"></span><span id="local-6989586621680794728"><span id="local-6989586621680794729"><span id="local-6989586621680794730"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793229"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794730"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794729"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794728"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794730"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794729"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794728"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-643"></span><span>    </span><span id="local-6989586621680793222"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b, c) -&gt; IO ()
</span><a href="#local-6989586621680793222"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793221"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793221"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793220"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793220"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793219"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793219"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793218"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793218"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793221"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793220"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793221"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793219"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; c -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793221"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793218"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-644"></span><span>    </span><span id="local-6989586621680793210"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b, c)
</span><a href="#local-6989586621680793210"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793209"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793209"><span class="hs-identifier hs-var">bh</span></a></span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793208"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793208"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793209"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-645"></span><span>                         </span><span id="local-6989586621680793207"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793207"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793209"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-646"></span><span>                         </span><span id="local-6989586621680793206"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793206"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO c
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793209"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-647"></span><span>                         </span><span class="annot"><span class="annottext">(a, b, c) -&gt; IO (a, b, c)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793208"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793207"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793206"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-648"></span><span>
</span><span id="line-649"></span><span id="local-6989586621680794724"><span id="local-6989586621680794725"><span id="local-6989586621680794726"><span id="local-6989586621680794727"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793203"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794727"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794726"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794725"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794724"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794727"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794726"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794725"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794724"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-650"></span><span>    </span><span id="local-6989586621680793194"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b, c, d) -&gt; IO ()
</span><a href="#local-6989586621680793194"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793193"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793193"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793192"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793192"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793191"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793191"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793190"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793190"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793189"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793189"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793193"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793192"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793193"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793191"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; c -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793193"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793190"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; d -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793193"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793189"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-651"></span><span>    </span><span id="local-6989586621680793179"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b, c, d)
</span><a href="#local-6989586621680793179"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793178"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793178"><span class="hs-identifier hs-var">bh</span></a></span></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793177"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793177"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793178"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-652"></span><span>                           </span><span id="local-6989586621680793176"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793176"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793178"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-653"></span><span>                           </span><span id="local-6989586621680793175"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793175"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO c
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793178"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-654"></span><span>                           </span><span id="local-6989586621680793174"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793174"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO d
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793178"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-655"></span><span>                           </span><span class="annot"><span class="annottext">(a, b, c, d) -&gt; IO (a, b, c, d)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793177"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793176"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793175"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793174"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span></span></span></span></span><span>
</span><span id="line-656"></span><span>
</span><span id="line-657"></span><span id="local-6989586621680794719"><span id="local-6989586621680794720"><span id="local-6989586621680794721"><span id="local-6989586621680794722"><span id="local-6989586621680794723"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793171"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794723"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794722"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794721"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794720"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794719"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794723"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794722"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794721"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794720"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621680794719"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-658"></span><span>    </span><span id="local-6989586621680793160"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b, c, d, e) -&gt; IO ()
</span><a href="#local-6989586621680793160"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793159"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793158"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793158"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793157"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793157"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793156"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793156"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793155"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793155"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793154"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793154"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793158"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793157"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; c -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793156"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; d -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793155"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; e -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793159"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793154"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-659"></span><span>    </span><span id="local-6989586621680793142"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b, c, d, e)
</span><a href="#local-6989586621680793142"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793141"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span></span><span>               </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793140"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793140"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-660"></span><span>                              </span><span id="local-6989586621680793139"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793139"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-661"></span><span>                              </span><span id="local-6989586621680793138"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793138"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO c
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-662"></span><span>                              </span><span id="local-6989586621680793137"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793137"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO d
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-663"></span><span>                              </span><span id="local-6989586621680793136"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793136"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO e
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793141"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-664"></span><span>                              </span><span class="annot"><span class="annottext">(a, b, c, d, e) -&gt; IO (a, b, c, d, e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793140"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793139"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793138"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793137"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793136"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span></span></span></span></span></span><span>
</span><span id="line-665"></span><span>
</span><span id="line-666"></span><span id="local-6989586621680794713"><span id="local-6989586621680794714"><span id="local-6989586621680794715"><span id="local-6989586621680794716"><span id="local-6989586621680794717"><span id="local-6989586621680794718"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793133"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794718"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794717"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794716"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794715"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794714"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794713"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794718"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794717"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794716"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794715"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621680794714"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621680794713"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-667"></span><span>    </span><span id="local-6989586621680793120"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b, c, d, e, f) -&gt; IO ()
</span><a href="#local-6989586621680793120"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793119"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793118"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793118"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793117"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793117"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793116"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793116"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793115"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793115"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793114"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793114"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680793113"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793113"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793118"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793117"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; c -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793116"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; d -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793115"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; e -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793114"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; f -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793119"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793113"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">;</span><span>
</span><span id="line-668"></span><span>    </span><span id="local-6989586621680793099"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b, c, d, e, f)
</span><a href="#local-6989586621680793099"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793098"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span></span><span>                  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793097"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793097"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-669"></span><span>                                 </span><span id="local-6989586621680793096"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793096"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-670"></span><span>                                 </span><span id="local-6989586621680793095"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793095"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO c
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-671"></span><span>                                 </span><span id="local-6989586621680793094"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793094"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO d
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-672"></span><span>                                 </span><span id="local-6989586621680793093"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793093"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO e
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-673"></span><span>                                 </span><span id="local-6989586621680793092"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793092"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO f
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793098"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-674"></span><span>                                 </span><span class="annot"><span class="annottext">(a, b, c, d, e, f) -&gt; IO (a, b, c, d, e, f)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793097"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793096"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793095"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793094"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793093"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793092"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span><span>
</span><span id="line-675"></span><span>
</span><span id="line-676"></span><span id="local-6989586621680794706"><span id="local-6989586621680794707"><span id="local-6989586621680794708"><span id="local-6989586621680794709"><span id="local-6989586621680794710"><span id="local-6989586621680794711"><span id="local-6989586621680794712"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793089"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794712"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794711"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794710"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794709"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794708"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794707"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794706"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794712"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794711"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794710"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794709"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794708"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794707"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621680794706"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-677"></span><span>    </span><span id="local-6989586621680793074"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; (a, b, c, d, e, f, g) -&gt; IO ()
</span><a href="#local-6989586621680793074"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793073"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680793072"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793072"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793071"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793071"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793070"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793070"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793069"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793069"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793068"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793068"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793067"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793067"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621680793066"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621680793066"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793072"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793071"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; c -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793070"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; d -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793069"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; e -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793068"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; f -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793067"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; g -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793073"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621680793066"><span class="hs-identifier hs-var">g</span></a></span><span>
</span><span id="line-678"></span><span>    </span><span id="local-6989586621680793050"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (a, b, c, d, e, f, g)
</span><a href="#local-6989586621680793050"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793049"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span></span><span>                  </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793048"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793048"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-679"></span><span>                                 </span><span id="local-6989586621680793047"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793047"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-680"></span><span>                                 </span><span id="local-6989586621680793046"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793046"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO c
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-681"></span><span>                                 </span><span id="local-6989586621680793045"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793045"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO d
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-682"></span><span>                                 </span><span id="local-6989586621680793044"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793044"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO e
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-683"></span><span>                                 </span><span id="local-6989586621680793043"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793043"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO f
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-684"></span><span>                                 </span><span id="local-6989586621680793042"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621680793042"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO g
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793049"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-685"></span><span>                                 </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g) -&gt; IO (a, b, c, d, e, f, g)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793048"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793047"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621680793046"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621680793045"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621680793044"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621680793043"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621680793042"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span><span>
</span><span id="line-686"></span><span>
</span><span id="line-687"></span><span id="local-6989586621680794705"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793039"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794705"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794705"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-688"></span><span>    </span><span id="local-6989586621680793033"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Maybe a -&gt; IO ()
</span><a href="#local-6989586621680793033"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793032"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793032"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793032"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-689"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680793031"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793031"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621680793030"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793030"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793031"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793031"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793030"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-690"></span><span>    </span><span id="local-6989586621680793022"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Maybe a)
</span><a href="#local-6989586621680793022"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680793021"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793021"><span class="hs-identifier hs-var">bh</span></a></span></span><span>           </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793020"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793020"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793021"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-691"></span><span>                          </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680793020"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-692"></span><span>                            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; IO (Maybe a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-693"></span><span>                            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680793019"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793019"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793021"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Maybe a -&gt; IO (Maybe a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793019"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-694"></span><span>
</span><span id="line-695"></span><span id="local-6989586621680794703"><span id="local-6989586621680794704"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680793016"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794704"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794703"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Either"><span class="hs-identifier hs-type">Either</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794704"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794703"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-696"></span><span>    </span><span id="local-6989586621680793008"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Either a b -&gt; IO ()
</span><a href="#local-6989586621680793008"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680793007"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793007"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-type">Left</span></a></span><span>  </span><span id="local-6989586621680793006"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793006"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793007"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793007"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680793006"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-697"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680793005"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793005"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-type">Right</span></a></span><span> </span><span id="local-6989586621680793004"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793004"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793005"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; b -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680793005"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680793004"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-698"></span><span>    </span><span id="local-6989586621680792994"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Either a b)
</span><a href="#local-6989586621680792994"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792993"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792993"><span class="hs-identifier hs-var">bh</span></a></span></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792992"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792992"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792993"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-699"></span><span>                           </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792992"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-700"></span><span>                             </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792991"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792991"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792993"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Either a b -&gt; IO (Either a b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Either a b
forall a b. a -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Left"><span class="hs-identifier hs-var">Left</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792991"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-701"></span><span>                             </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792990"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680792990"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO b
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792993"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Either a b -&gt; IO (Either a b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b -&gt; Either a b
forall a b. b -&gt; Either a b
</span><a href="../../base/src/Data.Either.html#Right"><span class="hs-identifier hs-var">Right</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680792990"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-702"></span><span>
</span><span id="line-703"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792987"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#UTCTime"><span class="hs-identifier hs-type">UTCTime</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-704"></span><span>    </span><span id="local-6989586621680792982"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; UTCTime -&gt; IO ()
</span><a href="#local-6989586621680792982"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792981"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792981"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792980"><span class="annot"><span class="annottext">UTCTime
</span><a href="#local-6989586621680792980"><span class="hs-identifier hs-var">u</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Day -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792981"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UTCTime -&gt; Day
</span><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#utctDay"><span class="hs-identifier hs-var hs-var">utctDay</span></a></span><span> </span><span class="annot"><span class="annottext">UTCTime
</span><a href="#local-6989586621680792980"><span class="hs-identifier hs-var">u</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-705"></span><span>                   </span><span class="annot"><span class="annottext">BinHandle -&gt; DiffTime -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792981"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UTCTime -&gt; DiffTime
</span><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#utctDayTime"><span class="hs-identifier hs-var hs-var">utctDayTime</span></a></span><span> </span><span class="annot"><span class="annottext">UTCTime
</span><a href="#local-6989586621680792980"><span class="hs-identifier hs-var">u</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-706"></span><span>    </span><span id="local-6989586621680792972"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO UTCTime
</span><a href="#local-6989586621680792972"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792971"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792971"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792970"><span class="annot"><span class="annottext">Day
</span><a href="#local-6989586621680792970"><span class="hs-identifier hs-var">day</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Day
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792971"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-707"></span><span>                </span><span id="local-6989586621680792969"><span class="annot"><span class="annottext">DiffTime
</span><a href="#local-6989586621680792969"><span class="hs-identifier hs-var">dayTime</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO DiffTime
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792971"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-708"></span><span>                </span><span class="annot"><span class="annottext">UTCTime -&gt; IO UTCTime
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(UTCTime -&gt; IO UTCTime) -&gt; UTCTime -&gt; IO UTCTime
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">UTCTime :: Day -&gt; DiffTime -&gt; UTCTime
</span><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#UTCTime"><span class="hs-identifier hs-type">UTCTime</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">utctDay :: Day
</span><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#utctDay"><span class="hs-identifier hs-var">utctDay</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Day
</span><a href="#local-6989586621680792970"><span class="hs-identifier hs-var">day</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">utctDayTime :: DiffTime
</span><a href="../../time/src/Data.Time.Clock.Internal.UTCTime.html#utctDayTime"><span class="hs-identifier hs-var">utctDayTime</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">DiffTime
</span><a href="#local-6989586621680792969"><span class="hs-identifier hs-var">dayTime</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-709"></span><span>
</span><span id="line-710"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792965"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../time/src/Data.Time.Calendar.Days.html#Day"><span class="hs-identifier hs-type">Day</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-711"></span><span>    </span><span id="local-6989586621680792962"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Day -&gt; IO ()
</span><a href="#local-6989586621680792962"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792961"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792961"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792960"><span class="annot"><span class="annottext">Day
</span><a href="#local-6989586621680792960"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Integer -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792961"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Day -&gt; Integer
</span><a href="../../time/src/Data.Time.Calendar.Days.html#toModifiedJulianDay"><span class="hs-identifier hs-var hs-var">toModifiedJulianDay</span></a></span><span> </span><span class="annot"><span class="annottext">Day
</span><a href="#local-6989586621680792960"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-712"></span><span>    </span><span id="local-6989586621680792955"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Day
</span><a href="#local-6989586621680792955"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792954"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792954"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792953"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792953"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Integer
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792954"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-713"></span><span>                </span><span class="annot"><span class="annottext">Day -&gt; IO Day
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Day -&gt; IO Day) -&gt; Day -&gt; IO Day
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ModifiedJulianDay :: Integer -&gt; Day
</span><a href="../../time/src/Data.Time.Calendar.Days.html#ModifiedJulianDay"><span class="hs-identifier hs-type">ModifiedJulianDay</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">toModifiedJulianDay :: Integer
</span><a href="../../time/src/Data.Time.Calendar.Days.html#toModifiedJulianDay"><span class="hs-identifier hs-var">toModifiedJulianDay</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792953"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-714"></span><span>
</span><span id="line-715"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792949"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../time/src/Data.Time.Clock.Internal.DiffTime.html#DiffTime"><span class="hs-identifier hs-type">DiffTime</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-716"></span><span>    </span><span id="local-6989586621680792943"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; DiffTime -&gt; IO ()
</span><a href="#local-6989586621680792943"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792942"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792942"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792941"><span class="annot"><span class="annottext">DiffTime
</span><a href="#local-6989586621680792941"><span class="hs-identifier hs-var">dt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Rational -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792942"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">DiffTime -&gt; Rational
forall a. Real a =&gt; a -&gt; Rational
</span><a href="../../base/src/GHC.Real.html#toRational"><span class="hs-identifier hs-var">toRational</span></a></span><span> </span><span class="annot"><span class="annottext">DiffTime
</span><a href="#local-6989586621680792941"><span class="hs-identifier hs-var">dt</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-717"></span><span>    </span><span id="local-6989586621680792934"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO DiffTime
</span><a href="#local-6989586621680792934"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792933"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792933"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792932"><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621680792932"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Rational
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792933"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-718"></span><span>                </span><span class="annot"><span class="annottext">DiffTime -&gt; IO DiffTime
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(DiffTime -&gt; IO DiffTime) -&gt; DiffTime -&gt; IO DiffTime
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Rational -&gt; DiffTime
forall a. Fractional a =&gt; Rational -&gt; a
</span><a href="../../base/src/GHC.Real.html#fromRational"><span class="hs-identifier hs-var">fromRational</span></a></span><span> </span><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621680792932"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-719"></span><span>
</span><span id="line-720"></span><span class="hs-comment">{-
Finally - a reasonable portable Integer instance.

We used to encode values in the Int32 range as such,
falling back to a string of all things. In either case
we stored a tag byte to discriminate between the two cases.

This made some sense as it's highly portable but also not very
efficient.

However GHC stores a surprisingly large number off large Integer
values. In the examples looked at between 25% and 50% of Integers
serialized were outside of the Int32 range.

Consider a valie like `2724268014499746065`, some sort of hash
actually generated by GHC.
In the old scheme this was encoded as a list of 19 chars. This
gave a size of 77 Bytes, one for the length of the list and 76
since we encode chars as Word32 as well.

We can easily do better. The new plan is:

* Start with a tag byte
  * 0 =&gt; Int64 (LEB128 encoded)
  * 1 =&gt; Negative large interger
  * 2 =&gt; Positive large integer
* Followed by the value:
  * Int64 is encoded as usual
  * Large integers are encoded as a list of bytes (Word8).
    We use Data.Bits which defines a bit order independent of the representation.
    Values are stored LSB first.

This means our example value `2724268014499746065` is now only 10 bytes large.
* One byte tag
* One byte for the length of the [Word8] list.
* 8 bytes for the actual date.

The new scheme also does not depend in any way on
architecture specific details.

We still use this scheme even with LEB128 available,
as it has less overhead for truly large numbers. (&gt; maxBound :: Int64)

The instance is used for in Binary Integer and Binary Rational in GHC.Types.Literal
-}</span><span>
</span><span id="line-765"></span><span>
</span><span id="line-766"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792929"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-767"></span><span>    </span><span id="local-6989586621680792912"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Integer -&gt; IO ()
</span><a href="#local-6989586621680792912"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792911"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792910"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span></span><span>
</span><span id="line-768"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&gt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792909"><span class="hs-identifier hs-var">lo64</span></a></span><span> </span><span class="annot"><span class="annottext">Bool -&gt; Bool -&gt; Bool
</span><span class="hs-operator hs-var">&amp;&amp;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;=</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792908"><span class="hs-identifier hs-var">hi64</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-769"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-770"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; Int64 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Int64
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-771"></span><span>      </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-772"></span><span>          </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">&lt;</span></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span>
</span><span id="line-773"></span><span>            </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-774"></span><span>            </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord8"><span class="hs-identifier hs-var">putWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-775"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; [Word8] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792911"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; [Word8]
</span><a href="GHC.Utils.Binary.html#unroll"><span class="hs-identifier hs-var">unroll</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; [Word8]) -&gt; Integer -&gt; [Word8]
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#abs"><span class="hs-identifier hs-var">abs</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621680792910"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-776"></span><span>      </span><span class="hs-keyword">where</span><span>
</span><span id="line-777"></span><span>        </span><span id="local-6989586621680792909"><span class="annot"><span class="annottext">lo64 :: Integer
</span><a href="#local-6989586621680792909"><span class="hs-identifier hs-var hs-var">lo64</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#minBound"><span class="hs-identifier hs-var">minBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-778"></span><span>        </span><span id="local-6989586621680792908"><span class="annot"><span class="annottext">hi64 :: Integer
</span><a href="#local-6989586621680792908"><span class="hs-identifier hs-var hs-var">hi64</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int64
forall a. Bounded a =&gt; a
</span><a href="../../base/src/GHC.Enum.html#maxBound"><span class="hs-identifier hs-var">maxBound</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-779"></span><span>    </span><span id="local-6989586621680792881"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Integer
</span><a href="#local-6989586621680792881"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792880"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792880"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-780"></span><span>      </span><span id="local-6989586621680792879"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792879"><span class="hs-identifier hs-var">int_kind</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getWord8"><span class="hs-identifier hs-var">getWord8</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792880"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-781"></span><span>      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792879"><span class="hs-identifier hs-var">int_kind</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-782"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int64 -&gt; Integer
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int64 -&gt; Integer) -&gt; IO Int64 -&gt; IO Integer
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/Control.Monad.html#%3C%24%21%3E"><span class="hs-operator hs-var">&lt;$!&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int64
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792880"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-783"></span><span>        </span><span class="hs-comment">-- Large integer</span><span>
</span><span id="line-784"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Integer
forall a. Num a =&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#negate"><span class="hs-identifier hs-var">negate</span></a></span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Integer) -&gt; IO Integer -&gt; IO Integer
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/Control.Monad.html#%3C%24%21%3E"><span class="hs-operator hs-var">&lt;$!&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">IO Integer
</span><a href="#local-6989586621680792878"><span class="hs-identifier hs-var">getInt</span></a></span><span>
</span><span id="line-785"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">IO Integer
</span><a href="#local-6989586621680792878"><span class="hs-identifier hs-var">getInt</span></a></span><span>
</span><span id="line-786"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO Integer
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary Integer - Invalid byte&quot;</span></span><span>
</span><span id="line-787"></span><span>        </span><span class="hs-keyword">where</span><span>
</span><span id="line-788"></span><span>          </span><span class="annot"><a href="#local-6989586621680792878"><span class="hs-identifier hs-type">getInt</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-789"></span><span>          </span><span id="local-6989586621680792878"><span class="annot"><span class="annottext">getInt :: IO Integer
</span><a href="#local-6989586621680792878"><span class="hs-identifier hs-var hs-var">getInt</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; Integer
</span><a href="GHC.Utils.Binary.html#roll"><span class="hs-identifier hs-var">roll</span></a></span><span> </span><span class="annot"><span class="annottext">([Word8] -&gt; Integer) -&gt; IO [Word8] -&gt; IO Integer
forall (m :: * -&gt; *) a b. Monad m =&gt; (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/Control.Monad.html#%3C%24%21%3E"><span class="hs-operator hs-var">&lt;$!&gt;</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO [Word8]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792880"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span><span class="hs-special">)</span><span>
</span><span id="line-790"></span><span>
</span><span id="line-791"></span><span class="annot"><a href="GHC.Utils.Binary.html#unroll"><span class="hs-identifier hs-type">unroll</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-792"></span><span id="unroll"><span class="annot"><span class="annottext">unroll :: Integer -&gt; [Word8]
</span><a href="GHC.Utils.Binary.html#unroll"><span class="hs-identifier hs-var hs-var">unroll</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Maybe (Word8, Integer)) -&gt; Integer -&gt; [Word8]
forall b a. (b -&gt; Maybe (a, b)) -&gt; b -&gt; [a]
</span><a href="../../base/src/Data.OldList.html#unfoldr"><span class="hs-identifier hs-var">unfoldr</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Maybe (Word8, Integer)
forall {b} {a}. (Integral b, Num a, Bits b) =&gt; b -&gt; Maybe (a, b)
</span><a href="#local-6989586621680792875"><span class="hs-identifier hs-var">step</span></a></span><span>
</span><span id="line-793"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-794"></span><span>    </span><span id="local-6989586621680792875"><span class="annot"><span class="annottext">step :: b -&gt; Maybe (a, b)
</span><a href="#local-6989586621680792875"><span class="hs-identifier hs-var hs-var">step</span></a></span></span><span> </span><span class="annot"><span class="annottext">b
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Maybe (a, b)
forall a. Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-795"></span><span>    </span><span class="annot"><a href="#local-6989586621680792875"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span id="local-6989586621680792862"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680792862"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a, b) -&gt; Maybe (a, b)
forall a. a -&gt; Maybe a
</span><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">b -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680792862"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621680792862"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">b -&gt; Int -&gt; b
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftR"><span class="hs-operator hs-var">`shiftR`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span class="hs-special">)</span><span>
</span><span id="line-796"></span><span>
</span><span id="line-797"></span><span class="annot"><a href="GHC.Utils.Binary.html#roll"><span class="hs-identifier hs-type">roll</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>
</span><span id="line-798"></span><span id="roll"><span class="annot"><span class="annottext">roll :: [Word8] -&gt; Integer
</span><a href="GHC.Utils.Binary.html#roll"><span class="hs-identifier hs-var hs-var">roll</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Word8 -&gt; Integer) -&gt; Integer -&gt; [Word8] -&gt; Integer
forall (t :: * -&gt; *) b a.
Foldable t =&gt;
(b -&gt; a -&gt; b) -&gt; b -&gt; t a -&gt; b
</span><a href="../../base/src/Data.Foldable.html#foldl%27"><span class="hs-identifier hs-var">foldl'</span></a></span><span> </span><span class="annot"><span class="annottext">Integer -&gt; Word8 -&gt; Integer
forall {a} {a}. (Bits a, Integral a, Num a) =&gt; a -&gt; a -&gt; a
</span><a href="#local-6989586621680792860"><span class="hs-identifier hs-var">unstep</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">([Word8] -&gt; Integer) -&gt; ([Word8] -&gt; [Word8]) -&gt; [Word8] -&gt; Integer
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8] -&gt; [Word8]
forall a. [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#reverse"><span class="hs-identifier hs-var">reverse</span></a></span><span>
</span><span id="line-799"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-800"></span><span>    </span><span id="local-6989586621680792860"><span class="annot"><span class="annottext">unstep :: a -&gt; a -&gt; a
</span><a href="#local-6989586621680792860"><span class="hs-identifier hs-var hs-var">unstep</span></a></span></span><span> </span><span id="local-6989586621680792850"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792850"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680792849"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792849"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792850"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; Int -&gt; a
forall a. Bits a =&gt; a -&gt; Int -&gt; a
</span><a href="../../base/src/Data.Bits.html#shiftL"><span class="hs-operator hs-var">`shiftL`</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">8</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Bits a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/Data.Bits.html#.%7C."><span class="hs-operator hs-var">.|.</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792849"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-801"></span><span>
</span><span id="line-802"></span><span>
</span><span id="line-803"></span><span>    </span><span class="hs-comment">{-
    -- This code is currently commented out.
    -- See https://gitlab.haskell.org/ghc/ghc/issues/3379#note_104346 for
    -- discussion.

    put_ bh (S# i#) = do putByte bh 0; put_ bh (I# i#)
    put_ bh (J# s# a#) = do
        putByte bh 1
        put_ bh (I# s#)
        let sz# = sizeofByteArray# a#  -- in *bytes*
        put_ bh (I# sz#)  -- in *bytes*
        putByteArray bh a# sz#

    get bh = do
        b &lt;- getByte bh
        case b of
          0 -&gt; do (I# i#) &lt;- get bh
                  return (S# i#)
          _ -&gt; do (I# s#) &lt;- get bh
                  sz &lt;- get bh
                  (BA a#) &lt;- getByteArray bh sz
                  return (J# s# a#)

putByteArray :: BinHandle -&gt; ByteArray# -&gt; Int# -&gt; IO ()
putByteArray bh a s# = loop 0#
  where loop n#
           | n# ==# s# = return ()
           | otherwise = do
                putByte bh (indexByteArray a n#)
                loop (n# +# 1#)

getByteArray :: BinHandle -&gt; Int -&gt; IO ByteArray
getByteArray bh (I# sz) = do
  (MBA arr) &lt;- newByteArray sz
  let loop n
           | n ==# sz = return ()
           | otherwise = do
                w &lt;- getByte bh
                writeByteArray arr n w
                loop (n +# 1#)
  loop 0#
  freezeByteArray arr
    -}</span><span>
</span><span id="line-846"></span><span>
</span><span id="line-847"></span><span class="hs-comment">{-
data ByteArray = BA ByteArray#
data MBA = MBA (MutableByteArray# RealWorld)

newByteArray :: Int# -&gt; IO MBA
newByteArray sz = IO $ \s -&gt;
  case newByteArray# sz s of { (# s, arr #) -&gt;
  (# s, MBA arr #) }

freezeByteArray :: MutableByteArray# RealWorld -&gt; IO ByteArray
freezeByteArray arr = IO $ \s -&gt;
  case unsafeFreezeByteArray# arr s of { (# s, arr #) -&gt;
  (# s, BA arr #) }

writeByteArray :: MutableByteArray# RealWorld -&gt; Int# -&gt; Word8 -&gt; IO ()
writeByteArray arr i (W8# w) = IO $ \s -&gt;
  case writeWord8Array# arr i w s of { s -&gt;
  (# s, () #) }

indexByteArray :: ByteArray# -&gt; Int# -&gt; Word8
indexByteArray a# n# = W8# (indexWord8Array# a# n#)

-}</span><span>
</span><span id="line-870"></span><span id="local-6989586621680794700"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792846"><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794700"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Real.html#Ratio"><span class="hs-identifier hs-type">Ratio</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794700"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-871"></span><span>    </span><span id="local-6989586621680792841"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Ratio a -&gt; IO ()
</span><a href="#local-6989586621680792841"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792840"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792840"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621680792839"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792839"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#%3A%25"><span class="hs-operator hs-type">:%</span></a></span><span> </span><span id="local-6989586621680792838"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792838"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792840"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792839"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792840"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792838"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-872"></span><span>    </span><span id="local-6989586621680792832"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Ratio a)
</span><a href="#local-6989586621680792832"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792831"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792831"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792830"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792830"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792831"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621680792829"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792829"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792831"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Ratio a -&gt; IO (Ratio a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792830"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ratio a
forall a. a -&gt; a -&gt; Ratio a
</span><a href="../../base/src/GHC.Real.html#%3A%25"><span class="hs-operator hs-var">:%</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792829"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-873"></span><span>
</span><span id="line-874"></span><span class="hs-comment">-- Instance uses fixed-width encoding to allow inserting</span><span>
</span><span id="line-875"></span><span class="hs-comment">-- Bin placeholders in the stream.</span><span>
</span><span id="line-876"></span><span id="local-6989586621680794680"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792826"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#Bin"><span class="hs-identifier hs-type">Bin</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794680"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-877"></span><span>  </span><span id="local-6989586621680792822"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="#local-6989586621680792822"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792821"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792821"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-type">BinPtr</span></a></span><span> </span><span id="local-6989586621680792820"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792820"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word32 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putWord32"><span class="hs-identifier hs-var">putWord32</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792821"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792820"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-878"></span><span>  </span><span id="local-6989586621680792815"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Bin a)
</span><a href="#local-6989586621680792815"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792814"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792814"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792813"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680792813"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word32
</span><a href="GHC.Utils.Binary.html#getWord32"><span class="hs-identifier hs-var">getWord32</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792814"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Bin a -&gt; IO (Bin a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Bin a
forall {k} (a :: k). Int -&gt; Bin a
</span><a href="GHC.Utils.Binary.html#BinPtr"><span class="hs-identifier hs-var">BinPtr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621680792813"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span></span><span>
</span><span id="line-879"></span><span>
</span><span id="line-880"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-881"></span><span class="hs-comment">-- Instances for Data.Typeable stuff</span><span>
</span><span id="line-882"></span><span>
</span><span id="line-883"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792810"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TyCon</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-884"></span><span>    </span><span id="local-6989586621680792798"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; TyCon -&gt; IO ()
</span><a href="#local-6989586621680792798"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792797"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792796"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-885"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; String -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConPackage"><span class="hs-identifier hs-var">tyConPackage</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-886"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; String -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConModule"><span class="hs-identifier hs-var">tyConModule</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-887"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; String -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; String
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConName"><span class="hs-identifier hs-var">tyConName</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-888"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; Int
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConKindArgs"><span class="hs-identifier hs-var">tyConKindArgs</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-889"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; KindRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792797"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TyCon -&gt; KindRep
</span><a href="../../base/src/Data.Typeable.Internal.html#tyConKindRep"><span class="hs-identifier hs-var">tyConKindRep</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792796"><span class="hs-identifier hs-var">tc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-890"></span><span>    </span><span id="local-6989586621680792779"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO TyCon
</span><a href="#local-6989586621680792779"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792778"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-891"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon
</span><a href="../../base/src/Data.Typeable.Internal.html#mkTyCon"><span class="hs-identifier hs-var">mkTyCon</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; IO String -&gt; IO (String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO String
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (String -&gt; String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; IO String -&gt; IO (String -&gt; Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO String
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (String -&gt; Int -&gt; KindRep -&gt; TyCon)
-&gt; IO String -&gt; IO (Int -&gt; KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO String
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (Int -&gt; KindRep -&gt; TyCon) -&gt; IO Int -&gt; IO (KindRep -&gt; TyCon)
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (KindRep -&gt; TyCon) -&gt; IO KindRep -&gt; IO TyCon
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO KindRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792778"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-892"></span><span>
</span><span id="line-893"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792774"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">VecCount</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-894"></span><span>    </span><span id="local-6989586621680792768"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; VecCount -&gt; IO ()
</span><a href="#local-6989586621680792768"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792767"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792767"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792767"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; IO ()) -&gt; (VecCount -&gt; Word8) -&gt; VecCount -&gt; IO ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (VecCount -&gt; Int) -&gt; VecCount -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">VecCount -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-895"></span><span>    </span><span id="local-6989586621680792762"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO VecCount
</span><a href="#local-6989586621680792762"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792761"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792761"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; VecCount
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; VecCount) -&gt; (Word8 -&gt; Int) -&gt; Word8 -&gt; VecCount
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; VecCount) -&gt; IO Word8 -&gt; IO VecCount
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792761"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-896"></span><span>
</span><span id="line-897"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792758"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">VecElem</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-898"></span><span>    </span><span id="local-6989586621680792752"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; VecElem -&gt; IO ()
</span><a href="#local-6989586621680792752"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792751"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792751"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792751"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; IO ()) -&gt; (VecElem -&gt; Word8) -&gt; VecElem -&gt; IO ()
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; Word8) -&gt; (VecElem -&gt; Int) -&gt; VecElem -&gt; Word8
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">VecElem -&gt; Int
forall a. Enum a =&gt; a -&gt; Int
</span><a href="../../base/src/GHC.Enum.html#fromEnum"><span class="hs-identifier hs-var">fromEnum</span></a></span><span>
</span><span id="line-899"></span><span>    </span><span id="local-6989586621680792746"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO VecElem
</span><a href="#local-6989586621680792746"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792745"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792745"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; VecElem
forall a. Enum a =&gt; Int -&gt; a
</span><a href="../../base/src/GHC.Enum.html#toEnum"><span class="hs-identifier hs-var">toEnum</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; VecElem) -&gt; (Word8 -&gt; Int) -&gt; Word8 -&gt; VecElem
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Int
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="../../base/src/GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="annot"><span class="annottext">(Word8 -&gt; VecElem) -&gt; IO Word8 -&gt; IO VecElem
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792745"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-900"></span><span>
</span><span id="line-901"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792742"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">RuntimeRep</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-902"></span><span>    </span><span id="local-6989586621680792713"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; RuntimeRep -&gt; IO ()
</span><a href="#local-6989586621680792713"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792712"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792712"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">VecRep</span></span><span> </span><span id="local-6989586621680792711"><span class="annot"><span class="annottext">VecCount
</span><a href="#local-6989586621680792711"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680792710"><span class="annot"><span class="annottext">VecElem
</span><a href="#local-6989586621680792710"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792712"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; VecCount -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792712"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">VecCount
</span><a href="#local-6989586621680792711"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; VecElem -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792712"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">VecElem
</span><a href="#local-6989586621680792710"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-903"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792709"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792709"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">TupleRep</span></span><span> </span><span id="local-6989586621680792708"><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621680792708"><span class="hs-identifier hs-var">reps</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792709"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; [RuntimeRep] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792709"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621680792708"><span class="hs-identifier hs-var">reps</span></a></span><span>
</span><span id="line-904"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792707"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792707"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">SumRep</span></span><span> </span><span id="local-6989586621680792706"><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621680792706"><span class="hs-identifier hs-var">reps</span></a></span></span><span class="hs-special">)</span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792707"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; [RuntimeRep] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792707"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[RuntimeRep]
</span><a href="#local-6989586621680792706"><span class="hs-identifier hs-var">reps</span></a></span><span>
</span><span id="line-905"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792705"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792705"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">LiftedRep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792705"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>
</span><span id="line-906"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792704"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792704"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">UnliftedRep</span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792704"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span>
</span><span id="line-907"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792703"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792703"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">IntRep</span></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792703"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span>
</span><span id="line-908"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792702"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792702"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">WordRep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792702"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">6</span></span><span>
</span><span id="line-909"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792701"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792701"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int64Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792701"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">7</span></span><span>
</span><span id="line-910"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792700"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792700"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word64Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792700"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">8</span></span><span>
</span><span id="line-911"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792699"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792699"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">AddrRep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792699"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">9</span></span><span>
</span><span id="line-912"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792698"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792698"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">FloatRep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792698"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">10</span></span><span>
</span><span id="line-913"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792697"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792697"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">DoubleRep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792697"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">11</span></span><span>
</span><span id="line-914"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792696"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792696"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int8Rep</span></span><span>         </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792696"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">12</span></span><span>
</span><span id="line-915"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792695"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792695"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word8Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792695"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">13</span></span><span>
</span><span id="line-916"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792694"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792694"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int16Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792694"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">14</span></span><span>
</span><span id="line-917"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792693"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792693"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word16Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792693"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">15</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 809
</span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792692"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792692"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int32Rep</span></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792692"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">16</span></span><span>
</span><span id="line-920"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792691"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792691"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word32Rep</span></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792691"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">17</span></span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-923"></span><span>    </span><span id="local-6989586621680792628"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO RuntimeRep
</span><a href="#local-6989586621680792628"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792627"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-924"></span><span>        </span><span id="local-6989586621680792626"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792626"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-925"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792626"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-926"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">VecCount -&gt; VecElem -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">VecRep</span></span><span> </span><span class="annot"><span class="annottext">(VecCount -&gt; VecElem -&gt; RuntimeRep)
-&gt; IO VecCount -&gt; IO (VecElem -&gt; RuntimeRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO VecCount
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (VecElem -&gt; RuntimeRep) -&gt; IO VecElem -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO VecElem
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-927"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">TupleRep</span></span><span> </span><span class="annot"><span class="annottext">([RuntimeRep] -&gt; RuntimeRep) -&gt; IO [RuntimeRep] -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [RuntimeRep]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-928"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[RuntimeRep] -&gt; RuntimeRep
</span><span class="hs-identifier hs-var">SumRep</span></span><span> </span><span class="annot"><span class="annottext">([RuntimeRep] -&gt; RuntimeRep) -&gt; IO [RuntimeRep] -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [RuntimeRep]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792627"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-929"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">LiftedRep</span></span><span>
</span><span id="line-930"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">UnliftedRep</span></span><span>
</span><span id="line-931"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">IntRep</span></span><span>
</span><span id="line-932"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">6</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">WordRep</span></span><span>
</span><span id="line-933"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">7</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int64Rep</span></span><span>
</span><span id="line-934"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">8</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word64Rep</span></span><span>
</span><span id="line-935"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">9</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">AddrRep</span></span><span>
</span><span id="line-936"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">10</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">FloatRep</span></span><span>
</span><span id="line-937"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">11</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">DoubleRep</span></span><span>
</span><span id="line-938"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">12</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int8Rep</span></span><span>
</span><span id="line-939"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">13</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word8Rep</span></span><span>
</span><span id="line-940"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">14</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int16Rep</span></span><span>
</span><span id="line-941"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">15</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word16Rep</span></span><span class="hs-cpp">
#if __GLASGOW_HASKELL__ &gt;= 809
</span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">16</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Int32Rep</span></span><span>
</span><span id="line-944"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">17</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; IO RuntimeRep
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><span class="hs-identifier hs-var">Word32Rep</span></span><span class="hs-cpp">
#endif
</span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO RuntimeRep
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.putRuntimeRep: invalid tag&quot;</span></span><span>
</span><span id="line-947"></span><span>
</span><span id="line-948"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792623"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">KindRep</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-949"></span><span>    </span><span id="local-6989586621680792593"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; KindRep -&gt; IO ()
</span><a href="#local-6989586621680792593"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792592"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792592"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepTyConApp</span></span><span> </span><span id="local-6989586621680792591"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792591"><span class="hs-identifier hs-var">tc</span></a></span></span><span> </span><span id="local-6989586621680792590"><span class="annot"><span class="annottext">[KindRep]
</span><a href="#local-6989586621680792590"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792592"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; TyCon -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792592"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792591"><span class="hs-identifier hs-var">tc</span></a></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; [KindRep] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792592"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[KindRep]
</span><a href="#local-6989586621680792590"><span class="hs-identifier hs-var">k</span></a></span><span>
</span><span id="line-950"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792589"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792589"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepVar</span></span><span> </span><span id="local-6989586621680792588"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792588"><span class="hs-identifier hs-var">bndr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792589"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792589"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792588"><span class="hs-identifier hs-var">bndr</span></a></span><span>
</span><span id="line-951"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792587"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792587"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepApp</span></span><span> </span><span id="local-6989586621680792586"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792586"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680792585"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792585"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792587"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; KindRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792587"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792586"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; KindRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792587"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792585"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-952"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792584"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792584"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepFun</span></span><span> </span><span id="local-6989586621680792583"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792583"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680792582"><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792582"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792584"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; KindRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792584"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792583"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; KindRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792584"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">KindRep
</span><a href="#local-6989586621680792582"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-953"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792581"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792581"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">KindRepTYPE</span></span><span> </span><span id="local-6989586621680792580"><span class="annot"><span class="annottext">RuntimeRep
</span><a href="#local-6989586621680792580"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792581"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; RuntimeRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792581"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">RuntimeRep
</span><a href="#local-6989586621680792580"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-954"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792579"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792579"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#KindRepTypeLit"><span class="hs-identifier hs-type">KindRepTypeLit</span></a></span><span> </span><span id="local-6989586621680792577"><span class="annot"><span class="annottext">TypeLitSort
</span><a href="#local-6989586621680792577"><span class="hs-identifier hs-var">sort</span></a></span></span><span> </span><span id="local-6989586621680792576"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792576"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792579"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeLitSort -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792579"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><a href="#local-6989586621680792577"><span class="hs-identifier hs-var">sort</span></a></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; String -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792579"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792576"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-955"></span><span>
</span><span id="line-956"></span><span>    </span><span id="local-6989586621680792539"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO KindRep
</span><a href="#local-6989586621680792539"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792538"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-957"></span><span>        </span><span id="local-6989586621680792537"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792537"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-958"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792537"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-959"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [KindRep] -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepTyConApp</span></span><span> </span><span class="annot"><span class="annottext">(TyCon -&gt; [KindRep] -&gt; KindRep)
-&gt; IO TyCon -&gt; IO ([KindRep] -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO TyCon
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO ([KindRep] -&gt; KindRep) -&gt; IO [KindRep] -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [KindRep]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-960"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Int -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepVar</span></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; KindRep) -&gt; IO Int -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-961"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; KindRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepApp</span></span><span> </span><span class="annot"><span class="annottext">(KindRep -&gt; KindRep -&gt; KindRep)
-&gt; IO KindRep -&gt; IO (KindRep -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO KindRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (KindRep -&gt; KindRep) -&gt; IO KindRep -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO KindRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-962"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">KindRep -&gt; KindRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepFun</span></span><span> </span><span class="annot"><span class="annottext">(KindRep -&gt; KindRep -&gt; KindRep)
-&gt; IO KindRep -&gt; IO (KindRep -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO KindRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (KindRep -&gt; KindRep) -&gt; IO KindRep -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO KindRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-963"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">RuntimeRep -&gt; KindRep
</span><span class="hs-identifier hs-var">KindRepTYPE</span></span><span> </span><span class="annot"><span class="annottext">(RuntimeRep -&gt; KindRep) -&gt; IO RuntimeRep -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO RuntimeRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-964"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">5</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; String -&gt; KindRep
</span><a href="../../base/src/Data.Typeable.Internal.html#KindRepTypeLit"><span class="hs-identifier hs-var">KindRepTypeLit</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeLitSort -&gt; String -&gt; KindRep)
-&gt; IO TypeLitSort -&gt; IO (String -&gt; KindRep)
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO TypeLitSort
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">IO (String -&gt; KindRep) -&gt; IO String -&gt; IO KindRep
forall (f :: * -&gt; *) a b. Applicative f =&gt; f (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var">&lt;*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO String
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792538"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-965"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO KindRep
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.putKindRep: invalid tag&quot;</span></span><span>
</span><span id="line-966"></span><span>
</span><span id="line-967"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792534"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TypeLitSort</span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-968"></span><span>    </span><span id="local-6989586621680792530"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; TypeLitSort -&gt; IO ()
</span><a href="#local-6989586621680792530"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792529"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792529"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitSymbol</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792529"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-969"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792528"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792528"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitNat</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792528"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-970"></span><span>    </span><span id="local-6989586621680792519"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO TypeLitSort
</span><a href="#local-6989586621680792519"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792518"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792518"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-971"></span><span>        </span><span id="local-6989586621680792517"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792517"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792518"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-972"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792517"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-973"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; IO TypeLitSort
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitSymbol</span></span><span>
</span><span id="line-974"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeLitSort -&gt; IO TypeLitSort
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeLitSort
</span><span class="hs-identifier hs-var">TypeLitNat</span></span><span>
</span><span id="line-975"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO TypeLitSort
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.putTypeLitSort: invalid tag&quot;</span></span><span>
</span><span id="line-976"></span><span>
</span><span id="line-977"></span><span id="local-6989586621680794673"><span class="annot"><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-type">putTypeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794673"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-978"></span><span class="hs-comment">-- Special handling for TYPE, (-&gt;), and RuntimeRep due to recursive kind</span><span>
</span><span id="line-979"></span><span class="hs-comment">-- relations.</span><span>
</span><span id="line-980"></span><span class="hs-comment">-- See Note [Mutually recursive representations of primitive types]</span><span>
</span><span id="line-981"></span><span id="putTypeRep"><span class="annot"><span class="annottext">putTypeRep :: forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var hs-var">putTypeRep</span></a></span></span><span> </span><span id="local-6989586621680792514"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792514"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792513"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792513"><span class="hs-identifier hs-var">rep</span></a></span></span><span>
</span><span id="line-982"></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792513"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep (*) -&gt; Maybe (a :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-983"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792514"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-984"></span><span class="annot"><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span id="local-6989586621680792505"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792505"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Con%27"><span class="hs-identifier hs-type">Con'</span></a></span><span> </span><span id="local-6989586621680792496"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792496"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span id="local-6989586621680792495"><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621680792495"><span class="hs-identifier hs-var">ks</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-985"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792505"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-986"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; TyCon -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792505"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792496"><span class="hs-identifier hs-var">con</span></a></span><span>
</span><span id="line-987"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; [SomeTypeRep] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792505"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621680792495"><span class="hs-identifier hs-var">ks</span></a></span><span>
</span><span id="line-988"></span><span class="annot"><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span id="local-6989586621680792494"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792494"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#App"><span class="hs-identifier hs-type">App</span></a></span><span> </span><span id="local-6989586621680792487"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792487"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span id="local-6989586621680792486"><span class="annot"><span class="annottext">TypeRep b
</span><a href="#local-6989586621680792486"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-989"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792494"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-990"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep a -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792494"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792487"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-991"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep b -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792494"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep b
</span><a href="#local-6989586621680792486"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-992"></span><span class="annot"><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span id="local-6989586621680792485"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792485"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-type">Fun</span></a></span><span> </span><span id="local-6989586621680792477"><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621680792477"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span id="local-6989586621680792476"><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621680792476"><span class="hs-identifier hs-var">res</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-993"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792485"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-994"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep arg -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792485"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621680792477"><span class="hs-identifier hs-var">arg</span></a></span><span>
</span><span id="line-995"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep res -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792485"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621680792476"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-996"></span><span>
</span><span id="line-997"></span><span class="annot"><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-type">getSomeTypeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span>
</span><span id="line-998"></span><span id="getSomeTypeRep"><span class="annot"><span class="annottext">getSomeTypeRep :: BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var hs-var">getSomeTypeRep</span></a></span></span><span> </span><span id="local-6989586621680792474"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-999"></span><span>    </span><span id="local-6989586621680792473"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792473"><span class="hs-identifier hs-var">tag</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span>
</span><span id="line-1000"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792473"><span class="hs-identifier hs-var">tag</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1001"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; IO SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; IO SomeTypeRep) -&gt; SomeTypeRep -&gt; IO SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (*) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span>
</span><span id="line-1002"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792472"><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792472"><span class="hs-identifier hs-var">con</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO TyCon
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TyCon</span></span><span>
</span><span id="line-1003"></span><span>                </span><span id="local-6989586621680792471"><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621680792471"><span class="hs-identifier hs-var">ks</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [SomeTypeRep]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-1004"></span><span>                </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; IO SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; IO SomeTypeRep) -&gt; SomeTypeRep -&gt; IO SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep Any -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep Any -&gt; SomeTypeRep) -&gt; TypeRep Any -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon -&gt; [SomeTypeRep] -&gt; TypeRep Any
forall k (a :: k). TyCon -&gt; [SomeTypeRep] -&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#mkTrCon"><span class="hs-identifier hs-var">mkTrCon</span></a></span><span> </span><span class="annot"><span class="annottext">TyCon
</span><a href="#local-6989586621680792472"><span class="hs-identifier hs-var">con</span></a></span><span> </span><span class="annot"><span class="annottext">[SomeTypeRep]
</span><a href="#local-6989586621680792471"><span class="hs-identifier hs-var">ks</span></a></span><span>
</span><span id="line-1005"></span><span>
</span><span id="line-1006"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792469"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792469"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1007"></span><span>                </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792464"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792464"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1008"></span><span>                </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792469"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1009"></span><span>                  </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-type">Fun</span></a></span><span> </span><span id="local-6989586621680792454"><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621680792454"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span id="local-6989586621680792453"><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621680792453"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-1010"></span><span>                      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621680792454"><span class="hs-identifier hs-var">arg</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg -&gt; TypeRep k -&gt; Maybe (arg :~~: k)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792464"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1011"></span><span>                        </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">arg :~~: k
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-1012"></span><span>                            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep res -&gt; TypeRep (TYPE r2)
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep res
</span><a href="#local-6989586621680792453"><span class="hs-identifier hs-var">res</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (TYPE r2) -&gt; TypeRep (*) -&gt; Maybe (TYPE r2 :~~: *)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep (*)
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Type</span></span><span class="hs-special">)</span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1013"></span><span>                              </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">TYPE r2 :~~: *
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; IO SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; IO SomeTypeRep) -&gt; SomeTypeRep -&gt; IO SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (a a) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep (a a) -&gt; SomeTypeRep) -&gt; TypeRep (a a) -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; TypeRep (a a)
forall k1 k2 (a :: k1 -&gt; k2) (b :: k1).
TypeRep a -&gt; TypeRep b -&gt; TypeRep (a b)
</span><a href="../../base/src/Type.Reflection.Unsafe.html#mkTrApp"><span class="hs-identifier hs-var">mkTrApp</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621680792469"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792464"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-1014"></span><span>                              </span><span class="annot"><span class="annottext">Maybe (TYPE r2 :~~: *)
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; IO SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch in type application&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1015"></span><span>                        </span><span class="annot"><span class="annottext">Maybe (arg :~~: k)
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; IO SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch in type application&quot;</span></span><span>
</span><span id="line-1016"></span><span>                             </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Found argument of kind: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep k -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792464"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1017"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Where the constructor:  &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792469"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1018"></span><span>                             </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Expects kind:           &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep arg
</span><a href="#local-6989586621680792454"><span class="hs-identifier hs-var">arg</span></a></span><span>
</span><span id="line-1019"></span><span>                             </span><span class="hs-special">]</span><span>
</span><span id="line-1020"></span><span>                  </span><span class="annot"><span class="annottext">TypeRep k
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; IO SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Applied non-arrow&quot;</span></span><span>
</span><span id="line-1021"></span><span>                       </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Applied type: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792469"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1022"></span><span>                       </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    To argument:  &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792464"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-1023"></span><span>                       </span><span class="hs-special">]</span><span>
</span><span id="line-1024"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792434"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792434"><span class="hs-identifier hs-var">arg</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1025"></span><span>                </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792432"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792432"><span class="hs-identifier hs-var">res</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792474"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1026"></span><span>                </span><span class="hs-keyword">if</span><span>
</span><span id="line-1027"></span><span>                  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#App"><span class="hs-identifier hs-type">App</span></a></span><span> </span><span id="local-6989586621680792429"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792429"><span class="hs-identifier hs-var">argkcon</span></a></span></span><span> </span><span class="annot"><span class="annottext">TypeRep b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792434"><span class="hs-identifier hs-var">arg</span></a></span><span>
</span><span id="line-1028"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#App"><span class="hs-identifier hs-type">App</span></a></span><span> </span><span id="local-6989586621680792426"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792426"><span class="hs-identifier hs-var">reskcon</span></a></span></span><span> </span><span class="annot"><span class="annottext">TypeRep b
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep k
forall k (a :: k). TypeRep a -&gt; TypeRep k
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRepKind"><span class="hs-identifier hs-var">typeRepKind</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792432"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-1029"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: TYPE
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792429"><span class="hs-identifier hs-var">argkcon</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep TYPE -&gt; Maybe (a :~~: TYPE)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep TYPE
</span><a href="#local-6989586621680792421"><span class="hs-identifier hs-var">tYPErep</span></a></span><span>
</span><span id="line-1030"></span><span>                  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: TYPE
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792426"><span class="hs-identifier hs-var">reskcon</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep TYPE -&gt; Maybe (a :~~: TYPE)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep TYPE
</span><a href="#local-6989586621680792421"><span class="hs-identifier hs-var">tYPErep</span></a></span><span>
</span><span id="line-1031"></span><span>                  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SomeTypeRep -&gt; IO SomeTypeRep
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(SomeTypeRep -&gt; IO SomeTypeRep) -&gt; SomeTypeRep -&gt; IO SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep (a -&gt; a) -&gt; SomeTypeRep
forall k (a :: k). TypeRep a -&gt; SomeTypeRep
</span><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-var">SomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">(TypeRep (a -&gt; a) -&gt; SomeTypeRep)
-&gt; TypeRep (a -&gt; a) -&gt; SomeTypeRep
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; TypeRep (a -&gt; a)
forall k (fun :: k) arg res.
(k ~ *, fun ~~ (arg -&gt; res)) =&gt;
TypeRep arg -&gt; TypeRep res -&gt; TypeRep fun
</span><a href="../../base/src/Data.Typeable.Internal.html#Fun"><span class="hs-identifier hs-var">Fun</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621680792434"><span class="hs-identifier hs-var">arg</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
TypeRep a
</span><a href="#local-6989586621680792432"><span class="hs-identifier hs-var">res</span></a></span><span>
</span><span id="line-1032"></span><span>                  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../base/src/GHC.Base.html#otherwise"><span class="hs-identifier hs-var">otherwise</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; IO SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Kind mismatch&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1033"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; [String] -&gt; IO SomeTypeRep
forall {m :: * -&gt; *} {a}. MonadFail m =&gt; String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var">failure</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Invalid SomeTypeRep&quot;</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-1034"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-1035"></span><span>    </span><span class="annot"><a href="#local-6989586621680792421"><span class="hs-identifier hs-type">tYPErep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">TYPE</span></span><span>
</span><span id="line-1036"></span><span>    </span><span id="local-6989586621680792421"><span class="annot"><span class="annottext">tYPErep :: TypeRep TYPE
</span><a href="#local-6989586621680792421"><span class="hs-identifier hs-var hs-var">tYPErep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TypeRep TYPE
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span>
</span><span id="line-1037"></span><span>
</span><span id="line-1038"></span><span>    </span><span id="local-6989586621680792436"><span class="annot"><span class="annottext">failure :: String -&gt; [String] -&gt; m a
</span><a href="#local-6989586621680792436"><span class="hs-identifier hs-var hs-var">failure</span></a></span></span><span> </span><span id="local-6989586621680792412"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792412"><span class="hs-identifier hs-var">description</span></a></span></span><span> </span><span id="local-6989586621680792411"><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621680792411"><span class="hs-identifier hs-var">info</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1039"></span><span>        </span><span class="annot"><span class="annottext">String -&gt; m a
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; m a) -&gt; String -&gt; m a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String
</span><a href="../../base/src/Data.OldList.html#unlines"><span class="hs-identifier hs-var">unlines</span></a></span><span> </span><span class="annot"><span class="annottext">([String] -&gt; String) -&gt; [String] -&gt; String
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.getSomeTypeRep: &quot;</span></span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792412"><span class="hs-identifier hs-var">description</span></a></span><span> </span><span class="hs-special">]</span><span>
</span><span id="line-1040"></span><span>                      </span><span class="annot"><span class="annottext">[String] -&gt; [String] -&gt; [String]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">ShowS -&gt; [String] -&gt; [String]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="../../base/src/GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    &quot;</span></span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[String]
</span><a href="#local-6989586621680792411"><span class="hs-identifier hs-var">info</span></a></span><span>
</span><span id="line-1041"></span><span>
</span><span id="line-1042"></span><span id="local-6989586621680794614"><span id="local-6989586621680794615"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792407"><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#Typeable"><span class="hs-identifier hs-type">Typeable</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794614"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621680794614"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794615"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1043"></span><span>    </span><span id="local-6989586621680792405"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="#local-6989586621680792405"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep a -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span>
</span><span id="line-1044"></span><span>    </span><span id="local-6989586621680792402"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (TypeRep a)
</span><a href="#local-6989586621680792402"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792401"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792401"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1045"></span><span>        </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792397"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792397"><span class="hs-identifier hs-var">rep</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792401"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1046"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792397"><span class="hs-identifier hs-var">rep</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; TypeRep a -&gt; Maybe (a :~~: a)
forall k1 k2 (a :: k1) (b :: k2).
TypeRep a -&gt; TypeRep b -&gt; Maybe (a :~~: b)
</span><a href="../../base/src/Data.Typeable.Internal.html#eqTypeRep"><span class="hs-operator hs-var">`eqTypeRep`</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792396"><span class="hs-identifier hs-var">expected</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1047"></span><span>            </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a :~~: a
</span><a href="../../base/src/Data.Type.Equality.html#HRefl"><span class="hs-identifier hs-var">HRefl</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; IO (TypeRep a)
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792397"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1048"></span><span>            </span><span class="annot"><span class="annottext">Maybe (a :~~: a)
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO (TypeRep a)
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO (TypeRep a)) -&gt; String -&gt; IO (TypeRep a)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">[String] -&gt; String
</span><a href="../../base/src/Data.OldList.html#unlines"><span class="hs-identifier hs-var">unlines</span></a></span><span>
</span><span id="line-1049"></span><span>                               </span><span class="hs-special">[</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary: Type mismatch&quot;</span></span><span>
</span><span id="line-1050"></span><span>                               </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Deserialized type: &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792397"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1051"></span><span>                               </span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;    Expected type:     &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792396"><span class="hs-identifier hs-var">expected</span></a></span><span>
</span><span id="line-1052"></span><span>                               </span><span class="hs-special">]</span><span>
</span><span id="line-1053"></span><span>     </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621680792396"><span class="annot"><span class="annottext">expected :: TypeRep a
</span><a href="#local-6989586621680792396"><span class="hs-identifier hs-var hs-var">expected</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">TypeRep a
forall {k} (a :: k). Typeable a =&gt; TypeRep a
</span><a href="../../base/src/Data.Typeable.Internal.html#typeRep"><span class="hs-identifier hs-var">typeRep</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#TypeRep"><span class="hs-identifier hs-type">TypeRep</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794614"><span class="hs-identifier hs-type">a</span></a></span></span></span><span>
</span><span id="line-1054"></span><span>
</span><span id="line-1055"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792385"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1056"></span><span>    </span><span id="local-6989586621680792383"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; SomeTypeRep -&gt; IO ()
</span><a href="#local-6989586621680792383"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792382"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792382"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/Data.Typeable.Internal.html#SomeTypeRep"><span class="hs-identifier hs-type">SomeTypeRep</span></a></span><span> </span><span id="local-6989586621680792381"><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792381"><span class="hs-identifier hs-var">rep</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; TypeRep a -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; TypeRep a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putTypeRep"><span class="hs-identifier hs-var">putTypeRep</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792382"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">TypeRep a
</span><a href="#local-6989586621680792381"><span class="hs-identifier hs-var">rep</span></a></span><span>
</span><span id="line-1057"></span><span>    </span><span id="local-6989586621680792380"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO SomeTypeRep
</span><a href="#local-6989586621680792380"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
</span><a href="GHC.Utils.Binary.html#getSomeTypeRep"><span class="hs-identifier hs-var">getSomeTypeRep</span></a></span><span>
</span><span id="line-1058"></span><span>
</span><span id="line-1059"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-1060"></span><span class="hs-comment">-- Lazy reading/writing</span><span>
</span><span id="line-1061"></span><span>
</span><span id="line-1062"></span><span id="local-6989586621680792379"><span class="annot"><a href="GHC.Utils.Binary.html#lazyPut"><span class="hs-identifier hs-type">lazyPut</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680792379"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680792379"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span>
</span><span id="line-1063"></span><span id="lazyPut"><span class="annot"><span class="annottext">lazyPut :: forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#lazyPut"><span class="hs-identifier hs-var hs-var">lazyPut</span></a></span></span><span> </span><span id="local-6989586621680792369"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792368"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792368"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1064"></span><span>    </span><span class="hs-comment">-- output the obj with a ptr to skip over it:</span><span>
</span><span id="line-1065"></span><span>    </span><span id="local-6989586621680792367"><span class="annot"><span class="annottext">Bin (Bin Any)
</span><a href="#local-6989586621680792367"><span class="hs-identifier hs-var">pre_a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Bin (Bin Any))
forall {k} (a :: k). BinHandle -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-var">tellBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1066"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin (Bin Any) -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin (Bin Any)
</span><a href="#local-6989586621680792367"><span class="hs-identifier hs-var">pre_a</span></a></span><span>       </span><span class="hs-comment">-- save a slot for the ptr</span><span>
</span><span id="line-1067"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792368"><span class="hs-identifier hs-var">a</span></a></span><span>           </span><span class="hs-comment">-- dump the object</span><span>
</span><span id="line-1068"></span><span>    </span><span id="local-6989586621680792366"><span class="annot"><span class="annottext">Bin Any
</span><a href="#local-6989586621680792366"><span class="hs-identifier hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Bin Any)
forall {k} (a :: k). BinHandle -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-var">tellBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span>     </span><span class="hs-comment">-- q = ptr to after object</span><span>
</span><span id="line-1069"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin (Bin Any) -&gt; Bin Any -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; Bin a -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putAt"><span class="hs-identifier hs-var">putAt</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin (Bin Any)
</span><a href="#local-6989586621680792367"><span class="hs-identifier hs-var">pre_a</span></a></span><span> </span><span class="annot"><span class="annottext">Bin Any
</span><a href="#local-6989586621680792366"><span class="hs-identifier hs-var">q</span></a></span><span>    </span><span class="hs-comment">-- fill in slot before a with ptr to q</span><span>
</span><span id="line-1070"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin Any -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-var">seekBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792369"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin Any
</span><a href="#local-6989586621680792366"><span class="hs-identifier hs-var">q</span></a></span><span>        </span><span class="hs-comment">-- finally carry on writing at q</span><span>
</span><span id="line-1071"></span><span>
</span><span id="line-1072"></span><span id="local-6989586621680792365"><span class="annot"><a href="GHC.Utils.Binary.html#lazyGet"><span class="hs-identifier hs-type">lazyGet</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680792365"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="#local-6989586621680792365"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-1073"></span><span id="lazyGet"><span class="annot"><span class="annottext">lazyGet :: forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#lazyGet"><span class="hs-identifier hs-var hs-var">lazyGet</span></a></span></span><span> </span><span id="local-6989586621680792355"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792355"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1074"></span><span>    </span><span id="local-6989586621680792354"><span class="annot"><span class="annottext">Bin Any
</span><a href="#local-6989586621680792354"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Bin Any)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792355"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-comment">-- a BinPtr</span><span>
</span><span id="line-1075"></span><span>    </span><span id="local-6989586621680792353"><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680792353"><span class="hs-identifier hs-var">p_a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Bin a)
forall {k} (a :: k). BinHandle -&gt; IO (Bin a)
</span><a href="GHC.Utils.Binary.html#tellBin"><span class="hs-identifier hs-var">tellBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792355"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1076"></span><span>    </span><span id="local-6989586621680792352"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792352"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO a -&gt; IO a
forall a. IO a -&gt; IO a
</span><a href="../../base/src/GHC.IO.Unsafe.html#unsafeInterleaveIO"><span class="hs-identifier hs-var">unsafeInterleaveIO</span></a></span><span> </span><span class="annot"><span class="annottext">(IO a -&gt; IO a) -&gt; IO a -&gt; IO a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1077"></span><span>        </span><span class="hs-comment">-- NB: Use a fresh off_r variable in the child thread, for thread</span><span>
</span><span id="line-1078"></span><span>        </span><span class="hs-comment">-- safety.</span><span>
</span><span id="line-1079"></span><span>        </span><span id="local-6989586621680792351"><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680792351"><span class="hs-identifier hs-var">off_r</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">IO FastMutInt
</span><a href="GHC.Data.FastMutInt.html#newFastMutInt"><span class="hs-identifier hs-var">newFastMutInt</span></a></span><span>
</span><span id="line-1080"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin a -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; Bin a -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getAt"><span class="hs-identifier hs-var">getAt</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792355"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">_off_r :: FastMutInt
</span><a href="GHC.Utils.Binary.html#_off_r"><span class="hs-identifier hs-var">_off_r</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">FastMutInt
</span><a href="#local-6989586621680792351"><span class="hs-identifier hs-var">off_r</span></a></span><span> </span><span class="hs-special">}</span><span> </span><span class="annot"><span class="annottext">Bin a
</span><a href="#local-6989586621680792353"><span class="hs-identifier hs-var">p_a</span></a></span><span>
</span><span id="line-1081"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Bin Any -&gt; IO ()
forall {k} (a :: k). BinHandle -&gt; Bin a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#seekBin"><span class="hs-identifier hs-var">seekBin</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792355"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Bin Any
</span><a href="#local-6989586621680792354"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="hs-comment">-- skip over the object for now</span><span>
</span><span id="line-1082"></span><span>    </span><span class="annot"><span class="annottext">a -&gt; IO a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680792352"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-1083"></span><span>
</span><span id="line-1084"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-1085"></span><span class="hs-comment">-- UserData</span><span>
</span><span id="line-1086"></span><span class="hs-comment">-- -----------------------------------------------------------------------------</span><span>
</span><span id="line-1087"></span><span>
</span><span id="line-1088"></span><span class="hs-comment">-- | Information we keep around during interface file</span><span>
</span><span id="line-1089"></span><span class="hs-comment">-- serialization/deserialization. Namely we keep the functions for serializing</span><span>
</span><span id="line-1090"></span><span class="hs-comment">-- and deserializing 'Name's and 'FastString's. We do this because we actually</span><span>
</span><span id="line-1091"></span><span class="hs-comment">-- use serialization in two distinct settings,</span><span>
</span><span id="line-1092"></span><span class="hs-comment">--</span><span>
</span><span id="line-1093"></span><span class="hs-comment">-- * When serializing interface files themselves</span><span>
</span><span id="line-1094"></span><span class="hs-comment">--</span><span>
</span><span id="line-1095"></span><span class="hs-comment">-- * When computing the fingerprint of an IfaceDecl (which we computing by</span><span>
</span><span id="line-1096"></span><span class="hs-comment">--   hashing its Binary serialization)</span><span>
</span><span id="line-1097"></span><span class="hs-comment">--</span><span>
</span><span id="line-1098"></span><span class="hs-comment">-- These two settings have different needs while serializing Names:</span><span>
</span><span id="line-1099"></span><span class="hs-comment">--</span><span>
</span><span id="line-1100"></span><span class="hs-comment">-- * Names in interface files are serialized via a symbol table (see Note</span><span>
</span><span id="line-1101"></span><span class="hs-comment">--   [Symbol table representation of names] in &quot;GHC.Iface.Binary&quot;).</span><span>
</span><span id="line-1102"></span><span class="hs-comment">--</span><span>
</span><span id="line-1103"></span><span class="hs-comment">-- * During fingerprinting a binding Name is serialized as the OccName and a</span><span>
</span><span id="line-1104"></span><span class="hs-comment">--   non-binding Name is serialized as the fingerprint of the thing they</span><span>
</span><span id="line-1105"></span><span class="hs-comment">--   represent. See Note [Fingerprinting IfaceDecls] for further discussion.</span><span>
</span><span id="line-1106"></span><span class="hs-comment">--</span><span>
</span><span id="line-1107"></span><span class="hs-keyword">data</span><span> </span><span id="UserData"><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-var">UserData</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1108"></span><span>   </span><span id="UserData"><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-var">UserData</span></a></span></span><span> </span><span class="hs-special">{</span><span>
</span><span id="line-1109"></span><span>        </span><span class="hs-comment">-- for *deserialising* only:</span><span>
</span><span id="line-1110"></span><span>        </span><span id="ud_get_name"><span class="annot"><span class="annottext">UserData -&gt; BinHandle -&gt; IO Name
</span><a href="GHC.Utils.Binary.html#ud_get_name"><span class="hs-identifier hs-var hs-var">ud_get_name</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1111"></span><span>        </span><span id="ud_get_fs"><span class="annot"><span class="annottext">UserData -&gt; BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#ud_get_fs"><span class="hs-identifier hs-var hs-var">ud_get_fs</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1112"></span><span>
</span><span id="line-1113"></span><span>        </span><span class="hs-comment">-- for *serialising* only:</span><span>
</span><span id="line-1114"></span><span>        </span><span id="ud_put_nonbinding_name"><span class="annot"><span class="annottext">UserData -&gt; BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_nonbinding_name"><span class="hs-identifier hs-var hs-var">ud_put_nonbinding_name</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-1115"></span><span>        </span><span class="hs-comment">-- ^ serialize a non-binding 'Name' (e.g. a reference to another</span><span>
</span><span id="line-1116"></span><span>        </span><span class="hs-comment">-- binding).</span><span>
</span><span id="line-1117"></span><span>        </span><span id="ud_put_binding_name"><span class="annot"><span class="annottext">UserData -&gt; BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_binding_name"><span class="hs-identifier hs-var hs-var">ud_put_binding_name</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">,</span><span>
</span><span id="line-1118"></span><span>        </span><span class="hs-comment">-- ^ serialize a binding 'Name' (e.g. the name of an IfaceDecl)</span><span>
</span><span id="line-1119"></span><span>        </span><span id="ud_put_fs"><span class="annot"><span class="annottext">UserData -&gt; BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_fs"><span class="hs-identifier hs-var hs-var">ud_put_fs</span></a></span></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-1120"></span><span>   </span><span class="hs-special">}</span><span>
</span><span id="line-1121"></span><span>
</span><span id="line-1122"></span><span class="annot"><a href="GHC.Utils.Binary.html#newReadState"><span class="hs-identifier hs-type">newReadState</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">)</span><span>   </span><span class="hs-comment">-- ^ how to deserialize 'Name's</span><span>
</span><span id="line-1123"></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1124"></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span>
</span><span id="line-1125"></span><span id="newReadState"><span class="annot"><span class="annottext">newReadState :: (BinHandle -&gt; IO Name) -&gt; (BinHandle -&gt; IO FastString) -&gt; UserData
</span><a href="GHC.Utils.Binary.html#newReadState"><span class="hs-identifier hs-var hs-var">newReadState</span></a></span></span><span> </span><span id="local-6989586621680792344"><span class="annot"><span class="annottext">BinHandle -&gt; IO Name
</span><a href="#local-6989586621680792344"><span class="hs-identifier hs-var">get_name</span></a></span></span><span> </span><span id="local-6989586621680792343"><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
</span><a href="#local-6989586621680792343"><span class="hs-identifier hs-var">get_fs</span></a></span></span><span>
</span><span id="line-1126"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UserData :: (BinHandle -&gt; IO Name)
-&gt; (BinHandle -&gt; IO FastString)
-&gt; (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; FastString -&gt; IO ())
-&gt; UserData
</span><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ud_get_name :: BinHandle -&gt; IO Name
</span><a href="GHC.Utils.Binary.html#ud_get_name"><span class="hs-identifier hs-var">ud_get_name</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Name
</span><a href="#local-6989586621680792344"><span class="hs-identifier hs-var">get_name</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1127"></span><span>               </span><span class="annot"><span class="annottext">ud_get_fs :: BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#ud_get_fs"><span class="hs-identifier hs-var">ud_get_fs</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
</span><a href="#local-6989586621680792343"><span class="hs-identifier hs-var">get_fs</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1128"></span><span>               </span><span class="annot"><span class="annottext">ud_put_nonbinding_name :: BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_nonbinding_name"><span class="hs-identifier hs-var">ud_put_nonbinding_name</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; BinHandle -&gt; Name -&gt; IO ()
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;put_nonbinding_name&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-1129"></span><span>               </span><span class="annot"><span class="annottext">ud_put_binding_name :: BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_binding_name"><span class="hs-identifier hs-var">ud_put_binding_name</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; BinHandle -&gt; Name -&gt; IO ()
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;put_binding_name&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-1130"></span><span>               </span><span class="annot"><span class="annottext">ud_put_fs :: BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_fs"><span class="hs-identifier hs-var">ud_put_fs</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; BinHandle -&gt; FastString -&gt; IO ()
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;put_fs&quot;</span></span><span>
</span><span id="line-1131"></span><span>             </span><span class="hs-special">}</span><span>
</span><span id="line-1132"></span><span>
</span><span id="line-1133"></span><span class="annot"><a href="GHC.Utils.Binary.html#newWriteState"><span class="hs-identifier hs-type">newWriteState</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1134"></span><span>                 </span><span class="hs-comment">-- ^ how to serialize non-binding 'Name's</span><span>
</span><span id="line-1135"></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1136"></span><span>                 </span><span class="hs-comment">-- ^ how to serialize binding 'Name's</span><span>
</span><span id="line-1137"></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1138"></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span>
</span><span id="line-1139"></span><span id="newWriteState"><span class="annot"><span class="annottext">newWriteState :: (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; FastString -&gt; IO ())
-&gt; UserData
</span><a href="GHC.Utils.Binary.html#newWriteState"><span class="hs-identifier hs-var hs-var">newWriteState</span></a></span></span><span> </span><span id="local-6989586621680792341"><span class="annot"><span class="annottext">BinHandle -&gt; Name -&gt; IO ()
</span><a href="#local-6989586621680792341"><span class="hs-identifier hs-var">put_nonbinding_name</span></a></span></span><span> </span><span id="local-6989586621680792340"><span class="annot"><span class="annottext">BinHandle -&gt; Name -&gt; IO ()
</span><a href="#local-6989586621680792340"><span class="hs-identifier hs-var">put_binding_name</span></a></span></span><span> </span><span id="local-6989586621680792339"><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
</span><a href="#local-6989586621680792339"><span class="hs-identifier hs-var">put_fs</span></a></span></span><span>
</span><span id="line-1140"></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">UserData :: (BinHandle -&gt; IO Name)
-&gt; (BinHandle -&gt; IO FastString)
-&gt; (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; Name -&gt; IO ())
-&gt; (BinHandle -&gt; FastString -&gt; IO ())
-&gt; UserData
</span><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ud_get_name :: BinHandle -&gt; IO Name
</span><a href="GHC.Utils.Binary.html#ud_get_name"><span class="hs-identifier hs-var">ud_get_name</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; BinHandle -&gt; IO Name
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;get_name&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-1141"></span><span>               </span><span class="annot"><span class="annottext">ud_get_fs :: BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#ud_get_fs"><span class="hs-identifier hs-var">ud_get_fs</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; BinHandle -&gt; IO FastString
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;get_fs&quot;</span></span><span class="hs-special">,</span><span>
</span><span id="line-1142"></span><span>               </span><span class="annot"><span class="annottext">ud_put_nonbinding_name :: BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_nonbinding_name"><span class="hs-identifier hs-var">ud_put_nonbinding_name</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Name -&gt; IO ()
</span><a href="#local-6989586621680792341"><span class="hs-identifier hs-var">put_nonbinding_name</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1143"></span><span>               </span><span class="annot"><span class="annottext">ud_put_binding_name :: BinHandle -&gt; Name -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_binding_name"><span class="hs-identifier hs-var">ud_put_binding_name</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Name -&gt; IO ()
</span><a href="#local-6989586621680792340"><span class="hs-identifier hs-var">put_binding_name</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-1144"></span><span>               </span><span class="annot"><span class="annottext">ud_put_fs :: BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_fs"><span class="hs-identifier hs-var">ud_put_fs</span></a></span><span>   </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
</span><a href="#local-6989586621680792339"><span class="hs-identifier hs-var">put_fs</span></a></span><span>
</span><span id="line-1145"></span><span>             </span><span class="hs-special">}</span><span>
</span><span id="line-1146"></span><span>
</span><span id="line-1147"></span><span id="local-6989586621680794830"><span class="annot"><a href="GHC.Utils.Binary.html#noUserData"><span class="hs-identifier hs-type">noUserData</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621680794830"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-1148"></span><span id="noUserData"><span class="annot"><span class="annottext">noUserData :: forall a. a
</span><a href="GHC.Utils.Binary.html#noUserData"><span class="hs-identifier hs-var hs-var">noUserData</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; a
forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var">undef</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;UserData&quot;</span></span><span>
</span><span id="line-1149"></span><span>
</span><span id="line-1150"></span><span id="local-6989586621680792338"><span class="annot"><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-type">undef</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="#local-6989586621680792338"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-1151"></span><span id="undef"><span class="annot"><span class="annottext">undef :: forall a. String -&gt; a
</span><a href="GHC.Utils.Binary.html#undef"><span class="hs-identifier hs-var hs-var">undef</span></a></span></span><span> </span><span id="local-6989586621680792337"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792337"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; a
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary.UserData: no &quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680792337"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1152"></span><span>
</span><span id="line-1153"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1154"></span><span class="hs-comment">-- The Dictionary</span><span>
</span><span id="line-1155"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1156"></span><span>
</span><span id="line-1157"></span><span class="hs-keyword">type</span><span> </span><span id="Dictionary"><span class="annot"><a href="GHC.Utils.Binary.html#Dictionary"><span class="hs-identifier hs-var">Dictionary</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="hs-comment">-- The dictionary</span><span>
</span><span id="line-1158"></span><span>                                       </span><span class="hs-comment">-- Should be 0-indexed</span><span>
</span><span id="line-1159"></span><span>
</span><span id="line-1160"></span><span class="annot"><a href="GHC.Utils.Binary.html#putDictionary"><span class="hs-identifier hs-type">putDictionary</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Types.Unique.FM.html#UniqFM"><span class="hs-identifier hs-type">UniqFM</span></a></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span class="hs-special">,</span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-1161"></span><span id="putDictionary"><span class="annot"><span class="annottext">putDictionary :: BinHandle -&gt; Int -&gt; UniqFM FastString (Int, FastString) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putDictionary"><span class="hs-identifier hs-var hs-var">putDictionary</span></a></span></span><span> </span><span id="local-6989586621680792336"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792336"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792335"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792335"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span id="local-6989586621680792334"><span class="annot"><span class="annottext">UniqFM FastString (Int, FastString)
</span><a href="#local-6989586621680792334"><span class="hs-identifier hs-var">dict</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1162"></span><span>  </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792336"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792335"><span class="hs-identifier hs-var">sz</span></a></span><span>
</span><span id="line-1163"></span><span>  </span><span class="annot"><span class="annottext">(FastString -&gt; IO ()) -&gt; [FastString] -&gt; IO ()
forall (t :: * -&gt; *) (m :: * -&gt; *) a b.
(Foldable t, Monad m) =&gt;
(a -&gt; m b) -&gt; t a -&gt; m ()
</span><a href="../../base/src/Data.Foldable.html#mapM_"><span class="hs-identifier hs-var">mapM_</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putFS"><span class="hs-identifier hs-var">putFS</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792336"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Array Int FastString -&gt; [FastString]
forall i e. Array i e -&gt; [e]
</span><a href="../../base/src/GHC.Arr.html#elems"><span class="hs-identifier hs-var">elems</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int, Int) -&gt; [(Int, FastString)] -&gt; Array Int FastString
forall i e. Ix i =&gt; (i, i) -&gt; [(i, e)] -&gt; Array i e
</span><a href="../../base/src/GHC.Arr.html#array"><span class="hs-identifier hs-var">array</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792335"><span class="hs-identifier hs-var">sz</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UniqFM FastString (Int, FastString) -&gt; [(Int, FastString)]
forall key elt. UniqFM key elt -&gt; [elt]
</span><a href="GHC.Types.Unique.FM.html#nonDetEltsUFM"><span class="hs-identifier hs-var">nonDetEltsUFM</span></a></span><span> </span><span class="annot"><span class="annottext">UniqFM FastString (Int, FastString)
</span><a href="#local-6989586621680792334"><span class="hs-identifier hs-var">dict</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1164"></span><span>    </span><span class="hs-comment">-- It's OK to use nonDetEltsUFM here because the elements have indices</span><span>
</span><span id="line-1165"></span><span>    </span><span class="hs-comment">-- that array uses to create order</span><span>
</span><span id="line-1166"></span><span>
</span><span id="line-1167"></span><span class="annot"><a href="GHC.Utils.Binary.html#getDictionary"><span class="hs-identifier hs-type">getDictionary</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Dictionary"><span class="hs-identifier hs-type">Dictionary</span></a></span><span>
</span><span id="line-1168"></span><span id="getDictionary"><span class="annot"><span class="annottext">getDictionary :: BinHandle -&gt; IO (Array Int FastString)
</span><a href="GHC.Utils.Binary.html#getDictionary"><span class="hs-identifier hs-var hs-var">getDictionary</span></a></span></span><span> </span><span id="local-6989586621680792331"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792331"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1169"></span><span>  </span><span id="local-6989586621680792330"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792330"><span class="hs-identifier hs-var">sz</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792331"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1170"></span><span>  </span><span id="local-6989586621680792329"><span class="annot"><span class="annottext">[FastString]
</span><a href="#local-6989586621680792329"><span class="hs-identifier hs-var">elems</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">[IO FastString] -&gt; IO [FastString]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; [IO FastString] -&gt; [IO FastString]
forall a. Int -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.List.html#take"><span class="hs-identifier hs-var">take</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792330"><span class="hs-identifier hs-var">sz</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">IO FastString -&gt; [IO FastString]
forall a. a -&gt; [a]
</span><a href="../../base/src/GHC.List.html#repeat"><span class="hs-identifier hs-var">repeat</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#getFS"><span class="hs-identifier hs-var">getFS</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792331"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1171"></span><span>  </span><span class="annot"><span class="annottext">Array Int FastString -&gt; IO (Array Int FastString)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Int, Int) -&gt; [FastString] -&gt; Array Int FastString
forall i e. Ix i =&gt; (i, i) -&gt; [e] -&gt; Array i e
</span><a href="../../base/src/GHC.Arr.html#listArray"><span class="hs-identifier hs-var">listArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792330"><span class="hs-identifier hs-var">sz</span></a></span><span class="annot"><span class="annottext">Int -&gt; Int -&gt; Int
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#-"><span class="hs-glyph hs-var">-</span></a></span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">[FastString]
</span><a href="#local-6989586621680792329"><span class="hs-identifier hs-var">elems</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1172"></span><span>
</span><span id="line-1173"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1174"></span><span class="hs-comment">-- The Symbol Table</span><span>
</span><span id="line-1175"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1176"></span><span>
</span><span id="line-1177"></span><span class="hs-comment">-- On disk, the symbol table is an array of IfExtName, when</span><span>
</span><span id="line-1178"></span><span class="hs-comment">-- reading it in we turn it into a SymbolTable.</span><span>
</span><span id="line-1179"></span><span>
</span><span id="line-1180"></span><span class="hs-keyword">type</span><span> </span><span id="SymbolTable"><span class="annot"><a href="GHC.Utils.Binary.html#SymbolTable"><span class="hs-identifier hs-var">SymbolTable</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="../../base/src/GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><a href="GHC.Types.Name.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span>
</span><span id="line-1181"></span><span>
</span><span id="line-1182"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1183"></span><span class="hs-comment">-- Reading and writing FastStrings</span><span>
</span><span id="line-1184"></span><span class="hs-comment">---------------------------------------------------------</span><span>
</span><span id="line-1185"></span><span>
</span><span id="line-1186"></span><span class="annot"><a href="GHC.Utils.Binary.html#putFS"><span class="hs-identifier hs-type">putFS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-1187"></span><span id="putFS"><span class="annot"><span class="annottext">putFS :: BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putFS"><span class="hs-identifier hs-var hs-var">putFS</span></a></span></span><span> </span><span id="local-6989586621680792324"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792324"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792323"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680792323"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; ByteString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putBS"><span class="hs-identifier hs-var">putBS</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792324"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">(ByteString -&gt; IO ()) -&gt; ByteString -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">FastString -&gt; ByteString
</span><a href="GHC.Data.FastString.html#bytesFS"><span class="hs-identifier hs-var">bytesFS</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680792323"><span class="hs-identifier hs-var">fs</span></a></span><span>
</span><span id="line-1188"></span><span>
</span><span id="line-1189"></span><span class="annot"><a href="GHC.Utils.Binary.html#getFS"><span class="hs-identifier hs-type">getFS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span><span>
</span><span id="line-1190"></span><span id="getFS"><span class="annot"><span class="annottext">getFS :: BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#getFS"><span class="hs-identifier hs-var hs-var">getFS</span></a></span></span><span> </span><span id="local-6989586621680792320"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792320"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1191"></span><span>  </span><span id="local-6989586621680792319"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792319"><span class="hs-identifier hs-var">l</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792320"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-1192"></span><span>  </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO FastString) -&gt; IO FastString
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792320"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792319"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680792318"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792318"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; IO FastString
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; IO FastString) -&gt; FastString -&gt; IO FastString
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24%21"><span class="hs-operator hs-var">$!</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Int -&gt; FastString
</span><a href="GHC.Data.FastString.html#mkFastStringBytes"><span class="hs-identifier hs-var">mkFastStringBytes</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792318"><span class="hs-identifier hs-var">src</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792319"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-1193"></span><span>
</span><span id="line-1194"></span><span class="annot"><a href="GHC.Utils.Binary.html#putBS"><span class="hs-identifier hs-type">putBS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-1195"></span><span id="putBS"><span class="annot"><span class="annottext">putBS :: BinHandle -&gt; ByteString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putBS"><span class="hs-identifier hs-var hs-var">putBS</span></a></span></span><span> </span><span id="local-6989586621680792316"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792316"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792315"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621680792315"><span class="hs-identifier hs-var">bs</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1196"></span><span>  </span><span class="annot"><span class="annottext">ByteString -&gt; (CStringLen -&gt; IO ()) -&gt; IO ()
forall a. ByteString -&gt; (CStringLen -&gt; IO a) -&gt; IO a
</span><a href="../../bytestring/src/Data.ByteString.Unsafe.html#unsafeUseAsCStringLen"><span class="hs-identifier hs-var">BS.unsafeUseAsCStringLen</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621680792315"><span class="hs-identifier hs-var">bs</span></a></span><span> </span><span class="annot"><span class="annottext">((CStringLen -&gt; IO ()) -&gt; IO ()) -&gt; (CStringLen -&gt; IO ()) -&gt; IO ()
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621680792313"><span class="annot"><span class="annottext">Ptr CChar
</span><a href="#local-6989586621680792313"><span class="hs-identifier hs-var">ptr</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621680792312"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792312"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1197"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792316"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792312"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-1198"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putPrim"><span class="hs-identifier hs-var">putPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792316"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792312"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680792311"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792311"><span class="hs-identifier hs-var">op</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
</span><a href="../../bytestring/src/Data.ByteString.Internal.html#memcpy"><span class="hs-identifier hs-var">BS.memcpy</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792311"><span class="hs-identifier hs-var">op</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Ptr CChar -&gt; Ptr Word8
forall a b. Ptr a -&gt; Ptr b
</span><a href="../../base/src/GHC.Ptr.html#castPtr"><span class="hs-identifier hs-var">castPtr</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr CChar
</span><a href="#local-6989586621680792313"><span class="hs-identifier hs-var">ptr</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792312"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1199"></span><span>
</span><span id="line-1200"></span><span class="annot"><a href="GHC.Utils.Binary.html#getBS"><span class="hs-identifier hs-type">getBS</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#BinHandle"><span class="hs-identifier hs-type">BinHandle</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span><span>
</span><span id="line-1201"></span><span id="getBS"><span class="annot"><span class="annottext">getBS :: BinHandle -&gt; IO ByteString
</span><a href="GHC.Utils.Binary.html#getBS"><span class="hs-identifier hs-var hs-var">getBS</span></a></span></span><span> </span><span id="local-6989586621680792308"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792308"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1202"></span><span>  </span><span id="local-6989586621680792307"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792307"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792308"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span>
</span><span id="line-1203"></span><span>  </span><span class="annot"><span class="annottext">Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ByteString
</span><a href="../../bytestring/src/Data.ByteString.Internal.html#create"><span class="hs-identifier hs-var">BS.create</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792307"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="annot"><span class="annottext">((Ptr Word8 -&gt; IO ()) -&gt; IO ByteString)
-&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ByteString
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680792305"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792305"><span class="hs-identifier hs-var">dest</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1204"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO ()) -&gt; IO ()
forall a. BinHandle -&gt; Int -&gt; (Ptr Word8 -&gt; IO a) -&gt; IO a
</span><a href="GHC.Utils.Binary.html#getPrim"><span class="hs-identifier hs-var">getPrim</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792308"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792307"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span id="local-6989586621680792304"><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792304"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ptr Word8 -&gt; Ptr Word8 -&gt; Int -&gt; IO ()
</span><a href="../../bytestring/src/Data.ByteString.Internal.html#memcpy"><span class="hs-identifier hs-var">BS.memcpy</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792305"><span class="hs-identifier hs-var">dest</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr Word8
</span><a href="#local-6989586621680792304"><span class="hs-identifier hs-var">src</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792307"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1205"></span><span>
</span><span id="line-1206"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792301"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../bytestring/src/Data.ByteString.Internal.html#ByteString"><span class="hs-identifier hs-type">ByteString</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1207"></span><span>  </span><span id="local-6989586621680792299"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; ByteString -&gt; IO ()
</span><a href="#local-6989586621680792299"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792298"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792298"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792297"><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621680792297"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; ByteString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putBS"><span class="hs-identifier hs-var">putBS</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792298"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">ByteString
</span><a href="#local-6989586621680792297"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1208"></span><span>  </span><span id="local-6989586621680792296"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO ByteString
</span><a href="#local-6989586621680792296"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792295"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792295"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO ByteString
</span><a href="GHC.Utils.Binary.html#getBS"><span class="hs-identifier hs-var">getBS</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792295"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1209"></span><span>
</span><span id="line-1210"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792292"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Data.FastString.html#FastString"><span class="hs-identifier hs-type">FastString</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1211"></span><span>  </span><span id="local-6989586621680792290"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FastString -&gt; IO ()
</span><a href="#local-6989586621680792290"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792289"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792289"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680792288"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680792288"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1212"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; UserData
</span><a href="GHC.Utils.Binary.html#getUserData"><span class="hs-identifier hs-var">getUserData</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792289"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1213"></span><span>        </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ud_put_fs :: UserData -&gt; BinHandle -&gt; FastString -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#ud_put_fs"><span class="hs-identifier hs-var">ud_put_fs</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621680792287"><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
</span><a href="#local-6989586621680792287"><span class="hs-identifier hs-var">put_fs</span></a></span></span><span> </span><span class="hs-special">}</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
</span><a href="#local-6989586621680792287"><span class="hs-identifier hs-var">put_fs</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792289"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680792288"><span class="hs-identifier hs-var">f</span></a></span><span>
</span><span id="line-1214"></span><span>
</span><span id="line-1215"></span><span>  </span><span id="local-6989586621680792286"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO FastString
</span><a href="#local-6989586621680792286"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792285"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792285"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-1216"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; UserData
</span><a href="GHC.Utils.Binary.html#getUserData"><span class="hs-identifier hs-var">getUserData</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792285"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1217"></span><span>        </span><span class="annot"><a href="GHC.Utils.Binary.html#UserData"><span class="hs-identifier hs-type">UserData</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">ud_get_fs :: UserData -&gt; BinHandle -&gt; IO FastString
</span><a href="GHC.Utils.Binary.html#ud_get_fs"><span class="hs-identifier hs-var">ud_get_fs</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="local-6989586621680792284"><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
</span><a href="#local-6989586621680792284"><span class="hs-identifier hs-var">get_fs</span></a></span></span><span> </span><span class="hs-special">}</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
</span><a href="#local-6989586621680792284"><span class="hs-identifier hs-var">get_fs</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792285"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1218"></span><span>
</span><span id="line-1219"></span><span class="hs-comment">-- Here to avoid loop</span><span>
</span><span id="line-1220"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792281"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#LeftOrRight"><span class="hs-identifier hs-type">LeftOrRight</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1221"></span><span>   </span><span id="local-6989586621680792277"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; LeftOrRight -&gt; IO ()
</span><a href="#local-6989586621680792277"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792276"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792276"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">LeftOrRight
</span><a href="GHC.Types.Basic.html#CLeft"><span class="hs-identifier hs-var">CLeft</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792276"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1222"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792274"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792274"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">LeftOrRight
</span><a href="GHC.Types.Basic.html#CRight"><span class="hs-identifier hs-var">CRight</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792274"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1223"></span><span>
</span><span id="line-1224"></span><span>   </span><span id="local-6989586621680792267"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO LeftOrRight
</span><a href="#local-6989586621680792267"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792266"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792266"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621680792265"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792265"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792266"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1225"></span><span>               </span><span class="hs-special">;</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792265"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1226"></span><span>                   </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">LeftOrRight -&gt; IO LeftOrRight
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">LeftOrRight
</span><a href="GHC.Types.Basic.html#CLeft"><span class="hs-identifier hs-var">CLeft</span></a></span><span>
</span><span id="line-1227"></span><span>                   </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">LeftOrRight -&gt; IO LeftOrRight
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">LeftOrRight
</span><a href="GHC.Types.Basic.html#CRight"><span class="hs-identifier hs-var">CRight</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-1228"></span><span>
</span><span id="line-1229"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792262"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#PromotionFlag"><span class="hs-identifier hs-type">PromotionFlag</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1230"></span><span>   </span><span id="local-6989586621680792258"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; PromotionFlag -&gt; IO ()
</span><a href="#local-6989586621680792258"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792257"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792257"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">PromotionFlag
</span><a href="GHC.Types.Basic.html#NotPromoted"><span class="hs-identifier hs-var">NotPromoted</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792257"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1231"></span><span>   </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792255"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792255"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">PromotionFlag
</span><a href="GHC.Types.Basic.html#IsPromoted"><span class="hs-identifier hs-var">IsPromoted</span></a></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792255"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1232"></span><span>
</span><span id="line-1233"></span><span>   </span><span id="local-6989586621680792245"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO PromotionFlag
</span><a href="#local-6989586621680792245"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792244"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792244"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1234"></span><span>       </span><span id="local-6989586621680792243"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792243"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792244"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1235"></span><span>       </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792243"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1236"></span><span>         </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">PromotionFlag -&gt; IO PromotionFlag
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">PromotionFlag
</span><a href="GHC.Types.Basic.html#NotPromoted"><span class="hs-identifier hs-var">NotPromoted</span></a></span><span>
</span><span id="line-1237"></span><span>         </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">PromotionFlag -&gt; IO PromotionFlag
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">PromotionFlag
</span><a href="GHC.Types.Basic.html#IsPromoted"><span class="hs-identifier hs-var">IsPromoted</span></a></span><span>
</span><span id="line-1238"></span><span>         </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO PromotionFlag
forall (m :: * -&gt; *) a. MonadFail m =&gt; String -&gt; m a
</span><a href="../../base/src/Control.Monad.Fail.html#fail"><span class="hs-identifier hs-var">fail</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary(IsPromoted): fail)&quot;</span></span><span>
</span><span id="line-1239"></span><span>
</span><span id="line-1240"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792240"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1241"></span><span>  </span><span id="local-6989586621680792235"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Fingerprint -&gt; IO ()
</span><a href="#local-6989586621680792235"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792234"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792234"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-type">Fingerprint</span></a></span><span> </span><span id="local-6989586621680792233"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792233"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span id="local-6989586621680792232"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792232"><span class="hs-identifier hs-var">w2</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word64 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792234"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792233"><span class="hs-identifier hs-var">w1</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word64 -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792234"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792232"><span class="hs-identifier hs-var">w2</span></a></span><span>
</span><span id="line-1242"></span><span>  </span><span id="local-6989586621680792226"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Fingerprint
</span><a href="#local-6989586621680792226"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span>  </span><span id="local-6989586621680792225"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792225"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792224"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792224"><span class="hs-identifier hs-var">w1</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word64
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792225"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">;</span><span> </span><span id="local-6989586621680792223"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792223"><span class="hs-identifier hs-var">w2</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word64
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792225"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">Fingerprint -&gt; IO Fingerprint
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Word64 -&gt; Word64 -&gt; Fingerprint
</span><a href="../../base/src/GHC.Fingerprint.Type.html#Fingerprint"><span class="hs-identifier hs-var">Fingerprint</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792224"><span class="hs-identifier hs-var">w1</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621680792223"><span class="hs-identifier hs-var">w2</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1243"></span><span>
</span><span id="line-1244"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792220"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#FunctionOrData"><span class="hs-identifier hs-type">FunctionOrData</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1245"></span><span>    </span><span id="local-6989586621680792216"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FunctionOrData -&gt; IO ()
</span><a href="#local-6989586621680792216"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792215"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792215"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><a href="GHC.Types.Basic.html#IsFunction"><span class="hs-identifier hs-var">IsFunction</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792215"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1246"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792213"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792213"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><a href="GHC.Types.Basic.html#IsData"><span class="hs-identifier hs-var">IsData</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792213"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1247"></span><span>    </span><span id="local-6989586621680792204"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO FunctionOrData
</span><a href="#local-6989586621680792204"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792203"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792203"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1248"></span><span>        </span><span id="local-6989586621680792202"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792202"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792203"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1249"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792202"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1250"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">FunctionOrData -&gt; IO FunctionOrData
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><a href="GHC.Types.Basic.html#IsFunction"><span class="hs-identifier hs-var">IsFunction</span></a></span><span>
</span><span id="line-1251"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">FunctionOrData -&gt; IO FunctionOrData
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">FunctionOrData
</span><a href="GHC.Types.Basic.html#IsData"><span class="hs-identifier hs-var">IsData</span></a></span><span>
</span><span id="line-1252"></span><span>          </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO FunctionOrData
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary FunctionOrData&quot;</span></span><span>
</span><span id="line-1253"></span><span>
</span><span id="line-1254"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792199"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#TupleSort"><span class="hs-identifier hs-type">TupleSort</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1255"></span><span>    </span><span id="local-6989586621680792194"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; TupleSort -&gt; IO ()
</span><a href="#local-6989586621680792194"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792193"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792193"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#BoxedTuple"><span class="hs-identifier hs-var">BoxedTuple</span></a></span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792193"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1256"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792191"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792191"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#UnboxedTuple"><span class="hs-identifier hs-var">UnboxedTuple</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792191"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1257"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792189"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792189"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#ConstraintTuple"><span class="hs-identifier hs-var">ConstraintTuple</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792189"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-1258"></span><span>    </span><span id="local-6989586621680792179"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO TupleSort
</span><a href="#local-6989586621680792179"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792178"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792178"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1259"></span><span>      </span><span id="local-6989586621680792177"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792177"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792178"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1260"></span><span>      </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792177"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1261"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">TupleSort -&gt; IO TupleSort
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#BoxedTuple"><span class="hs-identifier hs-var">BoxedTuple</span></a></span><span>
</span><span id="line-1262"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">TupleSort -&gt; IO TupleSort
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#UnboxedTuple"><span class="hs-identifier hs-var">UnboxedTuple</span></a></span><span>
</span><span id="line-1263"></span><span>        </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">TupleSort -&gt; IO TupleSort
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">TupleSort
</span><a href="GHC.Types.Basic.html#ConstraintTuple"><span class="hs-identifier hs-var">ConstraintTuple</span></a></span><span>
</span><span id="line-1264"></span><span>
</span><span id="line-1265"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792174"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#Activation"><span class="hs-identifier hs-type">Activation</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1266"></span><span>    </span><span id="local-6989586621680792159"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Activation -&gt; IO ()
</span><a href="#local-6989586621680792159"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792158"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792158"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#NeverActive"><span class="hs-identifier hs-var">NeverActive</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1267"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792158"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1268"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792156"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792156"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#FinalActive"><span class="hs-identifier hs-var">FinalActive</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1269"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792156"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1270"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792154"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792154"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#AlwaysActive"><span class="hs-identifier hs-var">AlwaysActive</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1271"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792154"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-1272"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792152"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792152"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#ActiveBefore"><span class="hs-identifier hs-type">ActiveBefore</span></a></span><span> </span><span id="local-6989586621680792150"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792150"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span id="local-6989586621680792149"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792149"><span class="hs-identifier hs-var">aa</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1273"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792152"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>
</span><span id="line-1274"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792152"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792150"><span class="hs-identifier hs-var">src</span></a></span><span>
</span><span id="line-1275"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792152"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792149"><span class="hs-identifier hs-var">aa</span></a></span><span>
</span><span id="line-1276"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792148"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792148"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#ActiveAfter"><span class="hs-identifier hs-type">ActiveAfter</span></a></span><span> </span><span id="local-6989586621680792146"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792146"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span id="local-6989586621680792145"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792145"><span class="hs-identifier hs-var">ab</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1277"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792148"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span>
</span><span id="line-1278"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792148"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792146"><span class="hs-identifier hs-var">src</span></a></span><span>
</span><span id="line-1279"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792148"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792145"><span class="hs-identifier hs-var">ab</span></a></span><span>
</span><span id="line-1280"></span><span>    </span><span id="local-6989586621680792122"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Activation
</span><a href="#local-6989586621680792122"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792121"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1281"></span><span>            </span><span id="local-6989586621680792120"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792120"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1282"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792120"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1283"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Activation -&gt; IO Activation
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#NeverActive"><span class="hs-identifier hs-var">NeverActive</span></a></span><span>
</span><span id="line-1284"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Activation -&gt; IO Activation
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#FinalActive"><span class="hs-identifier hs-var">FinalActive</span></a></span><span>
</span><span id="line-1285"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Activation -&gt; IO Activation
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="GHC.Types.Basic.html#AlwaysActive"><span class="hs-identifier hs-var">AlwaysActive</span></a></span><span>
</span><span id="line-1286"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792119"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792119"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1287"></span><span>                      </span><span id="local-6989586621680792118"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792118"><span class="hs-identifier hs-var">aa</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1288"></span><span>                      </span><span class="annot"><span class="annottext">Activation -&gt; IO Activation
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceText -&gt; Int -&gt; Activation
</span><a href="GHC.Types.Basic.html#ActiveBefore"><span class="hs-identifier hs-var">ActiveBefore</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792119"><span class="hs-identifier hs-var">src</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792118"><span class="hs-identifier hs-var">aa</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1289"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792117"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792117"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1290"></span><span>                      </span><span id="local-6989586621680792116"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792116"><span class="hs-identifier hs-var">ab</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792121"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1291"></span><span>                      </span><span class="annot"><span class="annottext">Activation -&gt; IO Activation
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceText -&gt; Int -&gt; Activation
</span><a href="GHC.Types.Basic.html#ActiveAfter"><span class="hs-identifier hs-var">ActiveAfter</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792117"><span class="hs-identifier hs-var">src</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680792116"><span class="hs-identifier hs-var">ab</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1292"></span><span>
</span><span id="line-1293"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792113"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#InlinePragma"><span class="hs-identifier hs-type">InlinePragma</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1294"></span><span>    </span><span id="local-6989586621680792102"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; InlinePragma -&gt; IO ()
</span><a href="#local-6989586621680792102"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792101"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#InlinePragma"><span class="hs-identifier hs-type">InlinePragma</span></a></span><span> </span><span id="local-6989586621680792099"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792099"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680792098"><span class="annot"><span class="annottext">InlineSpec
</span><a href="#local-6989586621680792098"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span id="local-6989586621680792097"><span class="annot"><span class="annottext">Maybe Int
</span><a href="#local-6989586621680792097"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span id="local-6989586621680792096"><span class="annot"><span class="annottext">Activation
</span><a href="#local-6989586621680792096"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span id="local-6989586621680792095"><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="#local-6989586621680792095"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1295"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792099"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1296"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; InlineSpec -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="#local-6989586621680792098"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-1297"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Maybe Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Int
</span><a href="#local-6989586621680792097"><span class="hs-identifier hs-var">b</span></a></span><span>
</span><span id="line-1298"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Activation -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="#local-6989586621680792096"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-1299"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; RuleMatchInfo -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792101"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="#local-6989586621680792095"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-1300"></span><span>
</span><span id="line-1301"></span><span>    </span><span id="local-6989586621680792083"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO InlinePragma
</span><a href="#local-6989586621680792083"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792082"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1302"></span><span>           </span><span id="local-6989586621680792081"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792081"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1303"></span><span>           </span><span id="local-6989586621680792080"><span class="annot"><span class="annottext">InlineSpec
</span><a href="#local-6989586621680792080"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO InlineSpec
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1304"></span><span>           </span><span id="local-6989586621680792079"><span class="annot"><span class="annottext">Maybe Int
</span><a href="#local-6989586621680792079"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Maybe Int)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1305"></span><span>           </span><span id="local-6989586621680792078"><span class="annot"><span class="annottext">Activation
</span><a href="#local-6989586621680792078"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Activation
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1306"></span><span>           </span><span id="local-6989586621680792077"><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="#local-6989586621680792077"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO RuleMatchInfo
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792082"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1307"></span><span>           </span><span class="annot"><span class="annottext">InlinePragma -&gt; IO InlinePragma
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceText
-&gt; InlineSpec
-&gt; Maybe Int
-&gt; Activation
-&gt; RuleMatchInfo
-&gt; InlinePragma
</span><a href="GHC.Types.Basic.html#InlinePragma"><span class="hs-identifier hs-var">InlinePragma</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680792081"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="#local-6989586621680792080"><span class="hs-identifier hs-var">a</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe Int
</span><a href="#local-6989586621680792079"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="annot"><span class="annottext">Activation
</span><a href="#local-6989586621680792078"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="#local-6989586621680792077"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1308"></span><span>
</span><span id="line-1309"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792074"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#RuleMatchInfo"><span class="hs-identifier hs-type">RuleMatchInfo</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1310"></span><span>    </span><span id="local-6989586621680792070"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; RuleMatchInfo -&gt; IO ()
</span><a href="#local-6989586621680792070"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792069"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792069"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="GHC.Types.Basic.html#FunLike"><span class="hs-identifier hs-var">FunLike</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792069"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1311"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792067"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792067"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="GHC.Types.Basic.html#ConLike"><span class="hs-identifier hs-var">ConLike</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792067"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1312"></span><span>    </span><span id="local-6989586621680792060"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO RuleMatchInfo
</span><a href="#local-6989586621680792060"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792059"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792059"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1313"></span><span>            </span><span id="local-6989586621680792058"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792058"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792059"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1314"></span><span>            </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792058"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; Word8 -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo -&gt; IO RuleMatchInfo
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="GHC.Types.Basic.html#ConLike"><span class="hs-identifier hs-var">ConLike</span></a></span><span>
</span><span id="line-1315"></span><span>                      </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo -&gt; IO RuleMatchInfo
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">RuleMatchInfo
</span><a href="GHC.Types.Basic.html#FunLike"><span class="hs-identifier hs-var">FunLike</span></a></span><span>
</span><span id="line-1316"></span><span>
</span><span id="line-1317"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792055"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#InlineSpec"><span class="hs-identifier hs-type">InlineSpec</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1318"></span><span>    </span><span id="local-6989586621680792049"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; InlineSpec -&gt; IO ()
</span><a href="#local-6989586621680792049"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792048"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792048"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#NoUserInline"><span class="hs-identifier hs-var">NoUserInline</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792048"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1319"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792046"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792046"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#Inline"><span class="hs-identifier hs-var">Inline</span></a></span><span>          </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792046"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1320"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792044"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792044"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#Inlinable"><span class="hs-identifier hs-var">Inlinable</span></a></span><span>       </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792044"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-1321"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792042"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792042"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#NoInline"><span class="hs-identifier hs-var">NoInline</span></a></span><span>        </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792042"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>
</span><span id="line-1322"></span><span>
</span><span id="line-1323"></span><span>    </span><span id="local-6989586621680792029"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO InlineSpec
</span><a href="#local-6989586621680792029"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792028"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792028"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680792027"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792027"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792028"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1324"></span><span>                </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792027"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1325"></span><span>                  </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">InlineSpec -&gt; IO InlineSpec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#NoUserInline"><span class="hs-identifier hs-var">NoUserInline</span></a></span><span>
</span><span id="line-1326"></span><span>                  </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">InlineSpec -&gt; IO InlineSpec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#Inline"><span class="hs-identifier hs-var">Inline</span></a></span><span>
</span><span id="line-1327"></span><span>                  </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">InlineSpec -&gt; IO InlineSpec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#Inlinable"><span class="hs-identifier hs-var">Inlinable</span></a></span><span>
</span><span id="line-1328"></span><span>                  </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">InlineSpec -&gt; IO InlineSpec
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">InlineSpec
</span><a href="GHC.Types.Basic.html#NoInline"><span class="hs-identifier hs-var">NoInline</span></a></span><span>
</span><span id="line-1329"></span><span>
</span><span id="line-1330"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792024"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#RecFlag"><span class="hs-identifier hs-type">RecFlag</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1331"></span><span>    </span><span id="local-6989586621680792020"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; RecFlag -&gt; IO ()
</span><a href="#local-6989586621680792020"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680792019"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792019"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RecFlag
</span><a href="GHC.Types.Basic.html#Recursive"><span class="hs-identifier hs-var">Recursive</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1332"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792019"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1333"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680792017"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792017"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">RecFlag
</span><a href="GHC.Types.Basic.html#NonRecursive"><span class="hs-identifier hs-var">NonRecursive</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1334"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792017"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1335"></span><span>    </span><span id="local-6989586621680792010"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO RecFlag
</span><a href="#local-6989586621680792010"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680792009"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792009"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1336"></span><span>            </span><span id="local-6989586621680792008"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792008"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680792009"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1337"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680792008"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1338"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">RecFlag -&gt; IO RecFlag
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">RecFlag
</span><a href="GHC.Types.Basic.html#Recursive"><span class="hs-identifier hs-var">Recursive</span></a></span><span>
</span><span id="line-1339"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">RecFlag -&gt; IO RecFlag
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">RecFlag
</span><a href="GHC.Types.Basic.html#NonRecursive"><span class="hs-identifier hs-var">NonRecursive</span></a></span><span>
</span><span id="line-1340"></span><span>
</span><span id="line-1341"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680792005"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#OverlapMode"><span class="hs-identifier hs-type">OverlapMode</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1342"></span><span>    </span><span id="local-6989586621680791988"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; OverlapMode -&gt; IO ()
</span><a href="#local-6989586621680791988"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791987"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791987"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#NoOverlap"><span class="hs-identifier hs-type">NoOverlap</span></a></span><span>    </span><span id="local-6989586621680791985"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791985"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791987"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791987"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791985"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1343"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791984"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791984"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#Overlaps"><span class="hs-identifier hs-type">Overlaps</span></a></span><span>     </span><span id="local-6989586621680791982"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791982"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791984"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791984"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791982"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1344"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791981"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791981"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#Incoherent"><span class="hs-identifier hs-type">Incoherent</span></a></span><span>   </span><span id="local-6989586621680791979"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791979"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791981"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791981"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791979"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1345"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791978"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791978"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#Overlapping"><span class="hs-identifier hs-type">Overlapping</span></a></span><span>  </span><span id="local-6989586621680791976"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791976"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791978"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791978"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791976"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1346"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791975"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791975"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#Overlappable"><span class="hs-identifier hs-type">Overlappable</span></a></span><span> </span><span id="local-6989586621680791973"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791973"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791975"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791975"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791973"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1347"></span><span>    </span><span id="local-6989586621680791944"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO OverlapMode
</span><a href="#local-6989586621680791944"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791943"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1348"></span><span>        </span><span id="local-6989586621680791942"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791942"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1349"></span><span>        </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791942"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1350"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO SourceText -&gt; (SourceText -&gt; IO OverlapMode) -&gt; IO OverlapMode
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680791941"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791941"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">OverlapMode -&gt; IO OverlapMode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(OverlapMode -&gt; IO OverlapMode) -&gt; OverlapMode -&gt; IO OverlapMode
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#NoOverlap"><span class="hs-identifier hs-var">NoOverlap</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791941"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1351"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO SourceText -&gt; (SourceText -&gt; IO OverlapMode) -&gt; IO OverlapMode
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680791940"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791940"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">OverlapMode -&gt; IO OverlapMode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(OverlapMode -&gt; IO OverlapMode) -&gt; OverlapMode -&gt; IO OverlapMode
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#Overlaps"><span class="hs-identifier hs-var">Overlaps</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791940"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1352"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO SourceText -&gt; (SourceText -&gt; IO OverlapMode) -&gt; IO OverlapMode
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680791939"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791939"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">OverlapMode -&gt; IO OverlapMode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(OverlapMode -&gt; IO OverlapMode) -&gt; OverlapMode -&gt; IO OverlapMode
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#Incoherent"><span class="hs-identifier hs-var">Incoherent</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791939"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1353"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO SourceText -&gt; (SourceText -&gt; IO OverlapMode) -&gt; IO OverlapMode
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680791938"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791938"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">OverlapMode -&gt; IO OverlapMode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(OverlapMode -&gt; IO OverlapMode) -&gt; OverlapMode -&gt; IO OverlapMode
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#Overlapping"><span class="hs-identifier hs-var">Overlapping</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791938"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1354"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791943"><span class="hs-identifier hs-var">bh</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">IO SourceText -&gt; (SourceText -&gt; IO OverlapMode) -&gt; IO OverlapMode
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621680791937"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791937"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">OverlapMode -&gt; IO OverlapMode
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(OverlapMode -&gt; IO OverlapMode) -&gt; OverlapMode -&gt; IO OverlapMode
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#Overlappable"><span class="hs-identifier hs-var">Overlappable</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791937"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1355"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO OverlapMode
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;get OverlapMode&quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791942"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1356"></span><span>
</span><span id="line-1357"></span><span>
</span><span id="line-1358"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791934"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#OverlapFlag"><span class="hs-identifier hs-type">OverlapFlag</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1359"></span><span>    </span><span id="local-6989586621680791929"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; OverlapFlag -&gt; IO ()
</span><a href="#local-6989586621680791929"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791928"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791928"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680791927"><span class="annot"><span class="annottext">OverlapFlag
</span><a href="#local-6989586621680791927"><span class="hs-identifier hs-var">flag</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; OverlapMode -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791928"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">OverlapFlag -&gt; OverlapMode
</span><a href="GHC.Types.Basic.html#overlapMode"><span class="hs-identifier hs-var hs-var">overlapMode</span></a></span><span> </span><span class="annot"><span class="annottext">OverlapFlag
</span><a href="#local-6989586621680791927"><span class="hs-identifier hs-var">flag</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1360"></span><span>                      </span><span class="annot"><span class="annottext">BinHandle -&gt; Bool -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791928"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">OverlapFlag -&gt; Bool
</span><a href="GHC.Types.Basic.html#isSafeOverlap"><span class="hs-identifier hs-var hs-var">isSafeOverlap</span></a></span><span> </span><span class="annot"><span class="annottext">OverlapFlag
</span><a href="#local-6989586621680791927"><span class="hs-identifier hs-var">flag</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1361"></span><span>    </span><span id="local-6989586621680791919"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO OverlapFlag
</span><a href="#local-6989586621680791919"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791918"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791918"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1362"></span><span>        </span><span id="local-6989586621680791917"><span class="annot"><span class="annottext">OverlapMode
</span><a href="#local-6989586621680791917"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO OverlapMode
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791918"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1363"></span><span>        </span><span id="local-6989586621680791916"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680791916"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Bool
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791918"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1364"></span><span>        </span><span class="annot"><span class="annottext">OverlapFlag -&gt; IO OverlapFlag
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">OverlapFlag :: OverlapMode -&gt; Bool -&gt; OverlapFlag
</span><a href="GHC.Types.Basic.html#OverlapFlag"><span class="hs-identifier hs-type">OverlapFlag</span></a></span><span> </span><span class="hs-special">{</span><span> </span><span class="annot"><span class="annottext">overlapMode :: OverlapMode
</span><a href="GHC.Types.Basic.html#overlapMode"><span class="hs-identifier hs-var">overlapMode</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">OverlapMode
</span><a href="#local-6989586621680791917"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">isSafeOverlap :: Bool
</span><a href="GHC.Types.Basic.html#isSafeOverlap"><span class="hs-identifier hs-var">isSafeOverlap</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621680791916"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-1365"></span><span>
</span><span id="line-1366"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791912"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#FixityDirection"><span class="hs-identifier hs-type">FixityDirection</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1367"></span><span>    </span><span id="local-6989586621680791907"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; FixityDirection -&gt; IO ()
</span><a href="#local-6989586621680791907"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791906"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791906"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixL"><span class="hs-identifier hs-var">InfixL</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1368"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791906"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1369"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791904"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791904"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixR"><span class="hs-identifier hs-var">InfixR</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1370"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791904"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1371"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791902"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791902"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixN"><span class="hs-identifier hs-var">InfixN</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1372"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791902"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-1373"></span><span>    </span><span id="local-6989586621680791892"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO FixityDirection
</span><a href="#local-6989586621680791892"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791891"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791891"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1374"></span><span>            </span><span id="local-6989586621680791890"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791890"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791891"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1375"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791890"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1376"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">FixityDirection -&gt; IO FixityDirection
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixL"><span class="hs-identifier hs-var">InfixL</span></a></span><span>
</span><span id="line-1377"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">FixityDirection -&gt; IO FixityDirection
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixR"><span class="hs-identifier hs-var">InfixR</span></a></span><span>
</span><span id="line-1378"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">FixityDirection -&gt; IO FixityDirection
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="GHC.Types.Basic.html#InfixN"><span class="hs-identifier hs-var">InfixN</span></a></span><span>
</span><span id="line-1379"></span><span>
</span><span id="line-1380"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791887"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#Fixity"><span class="hs-identifier hs-type">Fixity</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1381"></span><span>    </span><span id="local-6989586621680791880"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Fixity -&gt; IO ()
</span><a href="#local-6989586621680791880"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791879"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791879"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#Fixity"><span class="hs-identifier hs-type">Fixity</span></a></span><span> </span><span id="local-6989586621680791877"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791877"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span id="local-6989586621680791876"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791876"><span class="hs-identifier hs-var">aa</span></a></span></span><span> </span><span id="local-6989586621680791875"><span class="annot"><span class="annottext">FixityDirection
</span><a href="#local-6989586621680791875"><span class="hs-identifier hs-var">ab</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1382"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791879"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791877"><span class="hs-identifier hs-var">src</span></a></span><span>
</span><span id="line-1383"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791879"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791876"><span class="hs-identifier hs-var">aa</span></a></span><span>
</span><span id="line-1384"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; FixityDirection -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791879"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="#local-6989586621680791875"><span class="hs-identifier hs-var">ab</span></a></span><span>
</span><span id="line-1385"></span><span>    </span><span id="local-6989586621680791867"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Fixity
</span><a href="#local-6989586621680791867"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791866"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791866"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1386"></span><span>          </span><span id="local-6989586621680791865"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791865"><span class="hs-identifier hs-var">src</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791866"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1387"></span><span>          </span><span id="local-6989586621680791864"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791864"><span class="hs-identifier hs-var">aa</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791866"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1388"></span><span>          </span><span id="local-6989586621680791863"><span class="annot"><span class="annottext">FixityDirection
</span><a href="#local-6989586621680791863"><span class="hs-identifier hs-var">ab</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FixityDirection
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791866"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1389"></span><span>          </span><span class="annot"><span class="annottext">Fixity -&gt; IO Fixity
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceText -&gt; Int -&gt; FixityDirection -&gt; Fixity
</span><a href="GHC.Types.Basic.html#Fixity"><span class="hs-identifier hs-var">Fixity</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791865"><span class="hs-identifier hs-var">src</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791864"><span class="hs-identifier hs-var">aa</span></a></span><span> </span><span class="annot"><span class="annottext">FixityDirection
</span><a href="#local-6989586621680791863"><span class="hs-identifier hs-var">ab</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1390"></span><span>
</span><span id="line-1391"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791860"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#WarningTxt"><span class="hs-identifier hs-type">WarningTxt</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1392"></span><span>    </span><span id="local-6989586621680791845"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; WarningTxt -&gt; IO ()
</span><a href="#local-6989586621680791845"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791844"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791844"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#WarningTxt"><span class="hs-identifier hs-type">WarningTxt</span></a></span><span> </span><span id="local-6989586621680791842"><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791842"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680791841"><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791841"><span class="hs-identifier hs-var">w</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1393"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791844"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1394"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Located SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791844"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791842"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1395"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; [Located StringLiteral] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791844"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791841"><span class="hs-identifier hs-var">w</span></a></span><span>
</span><span id="line-1396"></span><span>    </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791840"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791840"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#DeprecatedTxt"><span class="hs-identifier hs-type">DeprecatedTxt</span></a></span><span> </span><span id="local-6989586621680791838"><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791838"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span id="local-6989586621680791837"><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791837"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1397"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791840"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1398"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Located SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791840"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791838"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1399"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; [Located StringLiteral] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791840"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791837"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-1400"></span><span>
</span><span id="line-1401"></span><span>    </span><span id="local-6989586621680791820"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO WarningTxt
</span><a href="#local-6989586621680791820"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791819"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1402"></span><span>            </span><span id="local-6989586621680791818"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791818"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1403"></span><span>            </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791818"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1404"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680791817"><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791817"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Located SourceText)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1405"></span><span>                      </span><span id="local-6989586621680791816"><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791816"><span class="hs-identifier hs-var">w</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [Located StringLiteral]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1406"></span><span>                      </span><span class="annot"><span class="annottext">WarningTxt -&gt; IO WarningTxt
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Located SourceText -&gt; [Located StringLiteral] -&gt; WarningTxt
</span><a href="GHC.Types.Basic.html#WarningTxt"><span class="hs-identifier hs-var">WarningTxt</span></a></span><span> </span><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791817"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791816"><span class="hs-identifier hs-var">w</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1407"></span><span>              </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680791815"><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791815"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Located SourceText)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1408"></span><span>                      </span><span id="local-6989586621680791814"><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791814"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [Located StringLiteral]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791819"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1409"></span><span>                      </span><span class="annot"><span class="annottext">WarningTxt -&gt; IO WarningTxt
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Located SourceText -&gt; [Located StringLiteral] -&gt; WarningTxt
</span><a href="GHC.Types.Basic.html#DeprecatedTxt"><span class="hs-identifier hs-var">DeprecatedTxt</span></a></span><span> </span><span class="annot"><span class="annottext">Located SourceText
</span><a href="#local-6989586621680791815"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="annot"><span class="annottext">[Located StringLiteral]
</span><a href="#local-6989586621680791814"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1410"></span><span>
</span><span id="line-1411"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791811"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#StringLiteral"><span class="hs-identifier hs-type">StringLiteral</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1412"></span><span>  </span><span id="local-6989586621680791806"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; StringLiteral -&gt; IO ()
</span><a href="#local-6989586621680791806"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791805"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791805"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#StringLiteral"><span class="hs-identifier hs-type">StringLiteral</span></a></span><span> </span><span id="local-6989586621680791803"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791803"><span class="hs-identifier hs-var">st</span></a></span></span><span> </span><span id="local-6989586621680791802"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791802"><span class="hs-identifier hs-var">fs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1413"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SourceText -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791805"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791803"><span class="hs-identifier hs-var">st</span></a></span><span>
</span><span id="line-1414"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791805"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791802"><span class="hs-identifier hs-var">fs</span></a></span><span>
</span><span id="line-1415"></span><span>  </span><span id="local-6989586621680791796"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO StringLiteral
</span><a href="#local-6989586621680791796"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791795"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791795"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1416"></span><span>            </span><span id="local-6989586621680791794"><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791794"><span class="hs-identifier hs-var">st</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SourceText
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791795"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1417"></span><span>            </span><span id="local-6989586621680791793"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791793"><span class="hs-identifier hs-var">fs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791795"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1418"></span><span>            </span><span class="annot"><span class="annottext">StringLiteral -&gt; IO StringLiteral
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SourceText -&gt; FastString -&gt; StringLiteral
</span><a href="GHC.Types.Basic.html#StringLiteral"><span class="hs-identifier hs-var">StringLiteral</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="#local-6989586621680791794"><span class="hs-identifier hs-var">st</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791793"><span class="hs-identifier hs-var">fs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1419"></span><span>
</span><span id="line-1420"></span><span id="local-6989586621680794592"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791790"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794592"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#Located"><span class="hs-identifier hs-type">Located</span></a></span><span> </span><span class="annot"><a href="#local-6989586621680794592"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1421"></span><span>    </span><span id="local-6989586621680791785"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Located a -&gt; IO ()
</span><a href="#local-6989586621680791785"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791784"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791784"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#L"><span class="hs-identifier hs-type">L</span></a></span><span> </span><span id="local-6989586621680791782"><span class="annot"><span class="annottext">SrcSpan
</span><a href="#local-6989586621680791782"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span id="local-6989586621680791781"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680791781"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1422"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; SrcSpan -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791784"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SrcSpan
</span><a href="#local-6989586621680791782"><span class="hs-identifier hs-var">l</span></a></span><span>
</span><span id="line-1423"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; a -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791784"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680791781"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-1424"></span><span>
</span><span id="line-1425"></span><span>    </span><span id="local-6989586621680791775"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO (Located a)
</span><a href="#local-6989586621680791775"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791774"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791774"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1426"></span><span>            </span><span id="local-6989586621680791773"><span class="annot"><span class="annottext">SrcSpan
</span><a href="#local-6989586621680791773"><span class="hs-identifier hs-var">l</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SrcSpan
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791774"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1427"></span><span>            </span><span id="local-6989586621680791772"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680791772"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO a
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791774"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1428"></span><span>            </span><span class="annot"><span class="annottext">Located a -&gt; IO (Located a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SrcSpan -&gt; a -&gt; Located a
forall l e. l -&gt; e -&gt; GenLocated l e
</span><a href="GHC.Types.SrcLoc.html#L"><span class="hs-identifier hs-var">L</span></a></span><span> </span><span class="annot"><span class="annottext">SrcSpan
</span><a href="#local-6989586621680791773"><span class="hs-identifier hs-var">l</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621680791772"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-1429"></span><span>
</span><span id="line-1430"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791769"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html#RealSrcSpan"><span class="hs-identifier hs-type">RealSrcSpan</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1431"></span><span>  </span><span id="local-6989586621680791758"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; RealSrcSpan -&gt; IO ()
</span><a href="#local-6989586621680791758"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791757"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680791756"><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1432"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; FastString
</span><a href="GHC.Types.SrcLoc.html#srcSpanFile"><span class="hs-identifier hs-var hs-var">srcSpanFile</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1433"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; Int
</span><a href="GHC.Types.SrcLoc.html#srcSpanStartLine"><span class="hs-identifier hs-var">srcSpanStartLine</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1434"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; Int
</span><a href="GHC.Types.SrcLoc.html#srcSpanStartCol"><span class="hs-identifier hs-var">srcSpanStartCol</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1435"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; Int
</span><a href="GHC.Types.SrcLoc.html#srcSpanEndLine"><span class="hs-identifier hs-var">srcSpanEndLine</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1436"></span><span>            </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791757"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; Int
</span><a href="GHC.Types.SrcLoc.html#srcSpanEndCol"><span class="hs-identifier hs-var">srcSpanEndCol</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791756"><span class="hs-identifier hs-var">ss</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1437"></span><span>
</span><span id="line-1438"></span><span>  </span><span id="local-6989586621680791739"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO RealSrcSpan
</span><a href="#local-6989586621680791739"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791738"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1439"></span><span>            </span><span id="local-6989586621680791737"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791737"><span class="hs-identifier hs-var">f</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1440"></span><span>            </span><span id="local-6989586621680791736"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791736"><span class="hs-identifier hs-var">sl</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1441"></span><span>            </span><span id="local-6989586621680791735"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791735"><span class="hs-identifier hs-var">sc</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1442"></span><span>            </span><span id="local-6989586621680791734"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791734"><span class="hs-identifier hs-var">el</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1443"></span><span>            </span><span id="local-6989586621680791733"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791733"><span class="hs-identifier hs-var">ec</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791738"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1444"></span><span>            </span><span class="annot"><span class="annottext">RealSrcSpan -&gt; IO RealSrcSpan
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcLoc -&gt; RealSrcLoc -&gt; RealSrcSpan
</span><a href="GHC.Types.SrcLoc.html#mkRealSrcSpan"><span class="hs-identifier hs-var">mkRealSrcSpan</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; Int -&gt; Int -&gt; RealSrcLoc
</span><a href="GHC.Types.SrcLoc.html#mkRealSrcLoc"><span class="hs-identifier hs-var">mkRealSrcLoc</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791737"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791736"><span class="hs-identifier hs-var">sl</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791735"><span class="hs-identifier hs-var">sc</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1445"></span><span>                                  </span><span class="hs-special">(</span><span class="annot"><span class="annottext">FastString -&gt; Int -&gt; Int -&gt; RealSrcLoc
</span><a href="GHC.Types.SrcLoc.html#mkRealSrcLoc"><span class="hs-identifier hs-var">mkRealSrcLoc</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791737"><span class="hs-identifier hs-var">f</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791734"><span class="hs-identifier hs-var">el</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791733"><span class="hs-identifier hs-var">ec</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-1446"></span><span>
</span><span id="line-1447"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791728"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html#BufPos"><span class="hs-identifier hs-type">BufPos</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1448"></span><span>  </span><span id="local-6989586621680791725"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; BufPos -&gt; IO ()
</span><a href="#local-6989586621680791725"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791724"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791724"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#BufPos"><span class="hs-identifier hs-type">BufPos</span></a></span><span> </span><span id="local-6989586621680791722"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791722"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Int -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791724"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621680791722"><span class="hs-identifier hs-var">i</span></a></span><span>
</span><span id="line-1449"></span><span>  </span><span id="local-6989586621680791719"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO BufPos
</span><a href="#local-6989586621680791719"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791718"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791718"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Int -&gt; BufPos
</span><a href="GHC.Types.SrcLoc.html#BufPos"><span class="hs-identifier hs-var">BufPos</span></a></span><span> </span><span class="annot"><span class="annottext">(Int -&gt; BufPos) -&gt; IO Int -&gt; IO BufPos
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Int
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791718"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1450"></span><span>
</span><span id="line-1451"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791715"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html#BufSpan"><span class="hs-identifier hs-type">BufSpan</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1452"></span><span>  </span><span id="local-6989586621680791710"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; BufSpan -&gt; IO ()
</span><a href="#local-6989586621680791710"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791709"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791709"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#BufSpan"><span class="hs-identifier hs-type">BufSpan</span></a></span><span> </span><span id="local-6989586621680791707"><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791707"><span class="hs-identifier hs-var">start</span></a></span></span><span> </span><span id="local-6989586621680791706"><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791706"><span class="hs-identifier hs-var">end</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1453"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; BufPos -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791709"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791707"><span class="hs-identifier hs-var">start</span></a></span><span>
</span><span id="line-1454"></span><span>    </span><span class="annot"><span class="annottext">BinHandle -&gt; BufPos -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791709"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791706"><span class="hs-identifier hs-var">end</span></a></span><span>
</span><span id="line-1455"></span><span>  </span><span id="local-6989586621680791700"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO BufSpan
</span><a href="#local-6989586621680791700"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791699"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791699"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1456"></span><span>    </span><span id="local-6989586621680791698"><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791698"><span class="hs-identifier hs-var">start</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO BufPos
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791699"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1457"></span><span>    </span><span id="local-6989586621680791697"><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791697"><span class="hs-identifier hs-var">end</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO BufPos
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791699"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1458"></span><span>    </span><span class="annot"><span class="annottext">BufSpan -&gt; IO BufSpan
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">BufPos -&gt; BufPos -&gt; BufSpan
</span><a href="GHC.Types.SrcLoc.html#BufSpan"><span class="hs-identifier hs-var">BufSpan</span></a></span><span> </span><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791698"><span class="hs-identifier hs-var">start</span></a></span><span> </span><span class="annot"><span class="annottext">BufPos
</span><a href="#local-6989586621680791697"><span class="hs-identifier hs-var">end</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1459"></span><span>
</span><span id="line-1460"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791694"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html#UnhelpfulSpanReason"><span class="hs-identifier hs-type">UnhelpfulSpanReason</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1461"></span><span>  </span><span id="local-6989586621680791685"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; UnhelpfulSpanReason -&gt; IO ()
</span><a href="#local-6989586621680791685"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791684"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span id="local-6989586621680791683"><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791683"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791683"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1462"></span><span>    </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulNoLocationInfo"><span class="hs-identifier hs-var">UnhelpfulNoLocationInfo</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1463"></span><span>    </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulWiredIn"><span class="hs-identifier hs-var">UnhelpfulWiredIn</span></a></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1464"></span><span>    </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulInteractive"><span class="hs-identifier hs-var">UnhelpfulInteractive</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span>
</span><span id="line-1465"></span><span>    </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulGenerated"><span class="hs-identifier hs-var">UnhelpfulGenerated</span></a></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span>
</span><span id="line-1466"></span><span>    </span><span class="annot"><a href="GHC.Types.SrcLoc.html#UnhelpfulOther"><span class="hs-identifier hs-type">UnhelpfulOther</span></a></span><span> </span><span id="local-6989586621680791677"><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791677"><span class="hs-identifier hs-var">fs</span></a></span></span><span>       </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">4</span></span><span> </span><span class="annot"><span class="annottext">IO () -&gt; IO () -&gt; IO ()
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; m b -&gt; m b
</span><a href="../../base/src/GHC.Base.html#%3E%3E"><span class="hs-operator hs-var">&gt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; FastString -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791684"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">FastString
</span><a href="#local-6989586621680791677"><span class="hs-identifier hs-var">fs</span></a></span><span>
</span><span id="line-1467"></span><span>
</span><span id="line-1468"></span><span>  </span><span id="local-6989586621680791661"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO UnhelpfulSpanReason
</span><a href="#local-6989586621680791661"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791660"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791660"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1469"></span><span>    </span><span id="local-6989586621680791659"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791659"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791660"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1470"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791659"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1471"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason -&gt; IO UnhelpfulSpanReason
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulNoLocationInfo"><span class="hs-identifier hs-var">UnhelpfulNoLocationInfo</span></a></span><span>
</span><span id="line-1472"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason -&gt; IO UnhelpfulSpanReason
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulWiredIn"><span class="hs-identifier hs-var">UnhelpfulWiredIn</span></a></span><span>
</span><span id="line-1473"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">2</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason -&gt; IO UnhelpfulSpanReason
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulInteractive"><span class="hs-identifier hs-var">UnhelpfulInteractive</span></a></span><span>
</span><span id="line-1474"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">3</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason -&gt; IO UnhelpfulSpanReason
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulGenerated"><span class="hs-identifier hs-var">UnhelpfulGenerated</span></a></span><span>
</span><span id="line-1475"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">FastString -&gt; UnhelpfulSpanReason
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulOther"><span class="hs-identifier hs-var">UnhelpfulOther</span></a></span><span> </span><span class="annot"><span class="annottext">(FastString -&gt; UnhelpfulSpanReason)
-&gt; IO FastString -&gt; IO UnhelpfulSpanReason
forall (f :: * -&gt; *) a b. Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
</span><a href="../../base/src/Data.Functor.html#%3C%24%3E"><span class="hs-operator hs-var">&lt;$&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO FastString
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791660"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1476"></span><span>
</span><span id="line-1477"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791656"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.SrcLoc.html#SrcSpan"><span class="hs-identifier hs-type">SrcSpan</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1478"></span><span>  </span><span id="local-6989586621680791645"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; SrcSpan -&gt; IO ()
</span><a href="#local-6989586621680791645"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791644"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791644"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#RealSrcSpan"><span class="hs-identifier hs-type">RealSrcSpan</span></a></span><span> </span><span id="local-6989586621680791642"><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791642"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span id="local-6989586621680791641"><span class="annot"><span class="annottext">Maybe BufSpan
</span><a href="#local-6989586621680791641"><span class="hs-identifier hs-var">sb</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1479"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791644"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1480"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; RealSrcSpan -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791644"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791642"><span class="hs-identifier hs-var">ss</span></a></span><span>
</span><span id="line-1481"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; Maybe BufSpan -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791644"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe BufSpan
</span><a href="#local-6989586621680791641"><span class="hs-identifier hs-var">sb</span></a></span><span>
</span><span id="line-1482"></span><span>
</span><span id="line-1483"></span><span>  </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791640"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791640"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.SrcLoc.html#UnhelpfulSpan"><span class="hs-identifier hs-type">UnhelpfulSpan</span></a></span><span> </span><span id="local-6989586621680791638"><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791638"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1484"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791640"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1485"></span><span>          </span><span class="annot"><span class="annottext">BinHandle -&gt; UnhelpfulSpanReason -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791640"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791638"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1486"></span><span>
</span><span id="line-1487"></span><span>  </span><span id="local-6989586621680791625"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO SrcSpan
</span><a href="#local-6989586621680791625"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791624"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791624"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1488"></span><span>          </span><span id="local-6989586621680791623"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791623"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791624"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1489"></span><span>          </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791623"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1490"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680791622"><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791622"><span class="hs-identifier hs-var">ss</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO RealSrcSpan
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791624"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1491"></span><span>                    </span><span id="local-6989586621680791621"><span class="annot"><span class="annottext">Maybe BufSpan
</span><a href="#local-6989586621680791621"><span class="hs-identifier hs-var">sb</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO (Maybe BufSpan)
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791624"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1492"></span><span>                    </span><span class="annot"><span class="annottext">SrcSpan -&gt; IO SrcSpan
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">RealSrcSpan -&gt; Maybe BufSpan -&gt; SrcSpan
</span><a href="GHC.Types.SrcLoc.html#RealSrcSpan"><span class="hs-identifier hs-var">RealSrcSpan</span></a></span><span> </span><span class="annot"><span class="annottext">RealSrcSpan
</span><a href="#local-6989586621680791622"><span class="hs-identifier hs-var">ss</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe BufSpan
</span><a href="#local-6989586621680791621"><span class="hs-identifier hs-var">sb</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1493"></span><span>            </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621680791620"><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791620"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO UnhelpfulSpanReason
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791624"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1494"></span><span>                    </span><span class="annot"><span class="annottext">SrcSpan -&gt; IO SrcSpan
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">UnhelpfulSpanReason -&gt; SrcSpan
</span><a href="GHC.Types.SrcLoc.html#UnhelpfulSpan"><span class="hs-identifier hs-var">UnhelpfulSpan</span></a></span><span> </span><span class="annot"><span class="annottext">UnhelpfulSpanReason
</span><a href="#local-6989586621680791620"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1495"></span><span>
</span><span id="line-1496"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791617"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="../../ghc-boot/src/GHC.Serialized.html#Serialized"><span class="hs-identifier hs-type">Serialized</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1497"></span><span>    </span><span id="local-6989586621680791612"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; Serialized -&gt; IO ()
</span><a href="#local-6989586621680791612"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791611"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791611"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-boot/src/GHC.Serialized.html#Serialized"><span class="hs-identifier hs-type">Serialized</span></a></span><span> </span><span id="local-6989586621680791609"><span class="annot"><span class="annottext">SomeTypeRep
</span><a href="#local-6989586621680791609"><span class="hs-identifier hs-var">the_type</span></a></span></span><span> </span><span id="local-6989586621680791608"><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621680791608"><span class="hs-identifier hs-var">bytes</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1498"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; SomeTypeRep -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791611"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">SomeTypeRep
</span><a href="#local-6989586621680791609"><span class="hs-identifier hs-var">the_type</span></a></span><span>
</span><span id="line-1499"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; [Word8] -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791611"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621680791608"><span class="hs-identifier hs-var">bytes</span></a></span><span>
</span><span id="line-1500"></span><span>    </span><span id="local-6989586621680791602"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO Serialized
</span><a href="#local-6989586621680791602"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791601"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791601"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1501"></span><span>        </span><span id="local-6989586621680791600"><span class="annot"><span class="annottext">SomeTypeRep
</span><a href="#local-6989586621680791600"><span class="hs-identifier hs-var">the_type</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO SomeTypeRep
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791601"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1502"></span><span>        </span><span id="local-6989586621680791599"><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621680791599"><span class="hs-identifier hs-var">bytes</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO [Word8]
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791601"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1503"></span><span>        </span><span class="annot"><span class="annottext">Serialized -&gt; IO Serialized
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">SomeTypeRep -&gt; [Word8] -&gt; Serialized
</span><a href="../../ghc-boot/src/GHC.Serialized.html#Serialized"><span class="hs-identifier hs-var">Serialized</span></a></span><span> </span><span class="annot"><span class="annottext">SomeTypeRep
</span><a href="#local-6989586621680791600"><span class="hs-identifier hs-var">the_type</span></a></span><span> </span><span class="annot"><span class="annottext">[Word8]
</span><a href="#local-6989586621680791599"><span class="hs-identifier hs-var">bytes</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1504"></span><span>
</span><span id="line-1505"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621680791596"><span class="annot"><a href="GHC.Utils.Binary.html#Binary"><span class="hs-identifier hs-type">Binary</span></a></span><span> </span><span class="annot"><a href="GHC.Types.Basic.html#SourceText"><span class="hs-identifier hs-type">SourceText</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-1506"></span><span>  </span><span id="local-6989586621680791589"><span class="annot"><span class="annottext">put_ :: BinHandle -&gt; SourceText -&gt; IO ()
</span><a href="#local-6989586621680791589"><span class="hs-identifier hs-var hs-var hs-var hs-var">put_</span></a></span></span><span> </span><span id="local-6989586621680791588"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791588"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="GHC.Types.Basic.html#NoSourceText"><span class="hs-identifier hs-var">NoSourceText</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791588"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span>
</span><span id="line-1507"></span><span>  </span><span class="annot"><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span id="local-6989586621680791586"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791586"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Types.Basic.html#SourceText"><span class="hs-identifier hs-type">SourceText</span></a></span><span> </span><span id="local-6989586621680791584"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680791584"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1508"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; Word8 -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#putByte"><span class="hs-identifier hs-var">putByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791586"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span>
</span><span id="line-1509"></span><span>        </span><span class="annot"><span class="annottext">BinHandle -&gt; String -&gt; IO ()
forall a. Binary a =&gt; BinHandle -&gt; a -&gt; IO ()
</span><a href="GHC.Utils.Binary.html#put_"><span class="hs-identifier hs-var">put_</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791586"><span class="hs-identifier hs-var">bh</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680791584"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-1510"></span><span>
</span><span id="line-1511"></span><span>  </span><span id="local-6989586621680791572"><span class="annot"><span class="annottext">get :: BinHandle -&gt; IO SourceText
</span><a href="#local-6989586621680791572"><span class="hs-identifier hs-var hs-var hs-var hs-var">get</span></a></span></span><span> </span><span id="local-6989586621680791571"><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791571"><span class="hs-identifier hs-var">bh</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1512"></span><span>    </span><span id="local-6989586621680791570"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791570"><span class="hs-identifier hs-var">h</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO Word8
</span><a href="GHC.Utils.Binary.html#getByte"><span class="hs-identifier hs-var">getByte</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791571"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1513"></span><span>    </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791570"><span class="hs-identifier hs-var">h</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-1514"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">0</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">SourceText -&gt; IO SourceText
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">SourceText
</span><a href="GHC.Types.Basic.html#NoSourceText"><span class="hs-identifier hs-var">NoSourceText</span></a></span><span>
</span><span id="line-1515"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-number">1</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-1516"></span><span>        </span><span id="local-6989586621680791569"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680791569"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">BinHandle -&gt; IO String
forall a. Binary a =&gt; BinHandle -&gt; IO a
</span><a href="GHC.Utils.Binary.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">BinHandle
</span><a href="#local-6989586621680791571"><span class="hs-identifier hs-var">bh</span></a></span><span>
</span><span id="line-1517"></span><span>        </span><span class="annot"><span class="annottext">SourceText -&gt; IO SourceText
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; SourceText
</span><a href="GHC.Types.Basic.html#SourceText"><span class="hs-identifier hs-var">SourceText</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621680791569"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-1518"></span><span>      </span><span class="annot"><span class="annottext">Word8
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">String -&gt; IO SourceText
forall a. String -&gt; a
</span><a href="GHC.Utils.Panic.Plain.html#panic"><span class="hs-identifier hs-var">panic</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; IO SourceText) -&gt; String -&gt; IO SourceText
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Binary SourceText:&quot;</span></span><span> </span><span class="annot"><span class="annottext">String -&gt; ShowS
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="../../base/src/GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">Word8 -&gt; String
forall a. Show a =&gt; a -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var">show</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621680791570"><span class="hs-identifier hs-var">h</span></a></span><span>
</span><span id="line-1519"></span></pre></body></html>